Merge pull request #84 in TSI/web-application-java from feature/TSI-3010 to develop

* commit '137e519db5c2d6eec107e7d0ec749f0823e9b51b':
  TSI-3011 Typo fix (TSI-3010)
  TSI-3011 Review fix (TSI-3010)
  TSI-3011 Review fix (TSI-3010)
  TSI-3011 Added data model extensions to public API (TSI-3010)
  TSI-3010 Added advanced way to save type information without additional changes from CM side (TSI-3011)
  TSI-3010 Moved Conditions to webapp & added support of any classes in extension data (TSI-3011)

Author: Alexey Zarakovskiy

dxa-framework/dxa-common-api/src/test/java/com/sdl/dxa/caching/wrapper/CacheTest.java

@@ -63,7 +63,7 @@ public void shouldDelegateKeyCalculationToConcreteCaches() {
         pagesCopyingCache.setKeyGenerator(keyGenerator);
         entitiesCache.setKeyGenerator(keyGenerator);
         MvcModelData mvcData = new MvcModelData("a", "a", "a", "c", "v", null);
-        PageModelData pageData = (PageModelData) new PageModelData("1", null, null, null, null, null, null, "/url")
+        PageModelData pageData = (PageModelData) new PageModelData("1", null, null, null, null, null, "/url")
                 .setMvcData(mvcData);
         EntityModelData entityMvcData = (EntityModelData) new EntityModelData("2", null, null, null, null, mvcData, "1", "/url", null, null, null)
                 .setMvcData(mvcData);

dxa-framework/dxa-data-model/src/main/java/com/sdl/dxa/api/datamodel/DataModelSpringConfiguration.java

@@ -9,7 +9,6 @@
 import com.fasterxml.jackson.datatype.joda.JodaModule;
 import com.sdl.dxa.api.datamodel.json.Polymorphic;
 import com.sdl.dxa.api.datamodel.json.PolymorphicObjectMixin;
-import com.sdl.dxa.api.datamodel.model.ViewModelData;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
@@ -43,7 +42,7 @@ public ObjectMapper dxaR2ObjectMapper() {
 
         ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
         scanner.addIncludeFilter(new AnnotationTypeFilter(Polymorphic.class));
-        scanner.findCandidateComponents(ViewModelData.class.getPackage().getName())
+        scanner.findCandidateComponents(DataModelSpringConfiguration.class.getPackage().getName())
                 .forEach(type -> {
                     try {
                         Class<?> aClass = forName(type.getBeanClassName(), getDefaultClassLoader());

dxa-framework/dxa-data-model/src/main/java/com/sdl/dxa/api/datamodel/json/Constants.java

@@ -0,0 +1,14 @@
+package com.sdl.dxa.api.datamodel.json;
+
+/**
+ * Basic constants for polymorphic JSON mapping.
+ */
+public final class Constants {
+
+    public static final String DOLLAR_TYPE = "$type";
+
+    public static final String LIST_MARKER = "[]";
+
+    private Constants() {
+    }
+}

dxa-framework/dxa-data-model/src/main/java/com/sdl/dxa/api/datamodel/json/ModelDataTypeIdResolver.java

@@ -6,18 +6,20 @@
 import com.fasterxml.jackson.databind.JavaType;
 import com.fasterxml.jackson.databind.jsontype.impl.TypeIdResolverBase;
 import com.fasterxml.jackson.databind.type.TypeFactory;
+import com.sdl.dxa.api.datamodel.DataModelSpringConfiguration;
 import com.sdl.dxa.api.datamodel.model.ViewModelData;
+import com.sdl.dxa.api.datamodel.model.util.HandlesTypeInformationForListWrapper;
 import com.sdl.dxa.api.datamodel.model.util.ListWrapper;
+import com.sdl.dxa.api.datamodel.model.util.UnknownClassesContentModelData;
 import lombok.extern.slf4j.Slf4j;
-import org.jetbrains.annotations.NotNull;
 import org.joda.time.DateTime;
 import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
 import org.springframework.core.type.filter.AnnotationTypeFilter;
 
-import java.io.IOException;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import static com.fasterxml.jackson.databind.type.TypeFactory.unknownType;
@@ -39,45 +41,39 @@
 @Slf4j
 public class ModelDataTypeIdResolver extends TypeIdResolverBase {
 
-    private static final String LIST_MARKER = "[]";
-
     private static final Map<String, JavaType> BASIC_MAPPING = new HashMap<>();
 
     static {
         Stream.of(Boolean.class, Character.class, Byte.class, Short.class, Integer.class, Long.class, Float.class,
-                Double.class, String.class).forEach(aClass -> {
-            addMapping(aClass.getSimpleName(), aClass);
-            addMapping(aClass.getSimpleName() + LIST_MARKER, ListWrapper.class, aClass);
-        });
+                Double.class, String.class).forEach(aClass -> addMapping(aClass.getSimpleName(), aClass, null));
 
-        Stream.of(Date.class, DateTime.class).forEach(aClass -> {
-            addMapping(aClass.getSimpleName(), String.class);
-            addMapping(aClass.getSimpleName() + LIST_MARKER, ListWrapper.class, String.class);
-        });
+        Stream.of(Date.class, DateTime.class).forEach(aClass -> addMapping(aClass.getSimpleName(), String.class, null));
 
         ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
         scanner.addIncludeFilter(new AnnotationTypeFilter(JsonTypeName.class));
-        scanner.findCandidateComponents(ViewModelData.class.getPackage().getName())
+        scanner.findCandidateComponents(DataModelSpringConfiguration.class.getPackage().getName())
                 .forEach(type -> {
                     try {
                         Class<?> aClass = forName(type.getBeanClassName(), getDefaultClassLoader());
                         JsonTypeName typeName = aClass.getAnnotation(JsonTypeName.class);
-                        addMapping(defaultIfBlank(typeName.value(), aClass.getSimpleName()), aClass);
+                        addMapping(defaultIfBlank(typeName.value(), aClass.getSimpleName()), aClass, null);
                     } catch (ClassNotFoundException e) {
                         log.warn("Class not found while mapping model data to typeIDs. Should never happen.", e);
                     }
                 });
-    }
 
-    private static void addMapping(String classId, Class<?> basicClass) {
-        addMapping(classId, basicClass, null);
+        // now go through all the mappings to add all additional [] that are not yet added (= no explicit implementation for it)
+        BASIC_MAPPING.entrySet().stream()
+                .filter(entry -> !entry.getKey().contains(Constants.LIST_MARKER))
+                .filter(entry -> !BASIC_MAPPING.containsKey(entry.getKey() + Constants.LIST_MARKER))
+                .collect(Collectors.toList())
+                .forEach(entry -> addMapping(entry.getKey() + Constants.LIST_MARKER, ListWrapper.class, entry.getValue().getRawClass()));
     }
 
     private static void addMapping(String classId, Class<?> basicClass, Class<?> genericClass) {
         JavaType javaType = genericClass == null ?
                 TypeFactory.defaultInstance().constructSpecializedType(unknownType(), basicClass) :
                 TypeFactory.defaultInstance().constructParametricType(basicClass, genericClass);
-
         BASIC_MAPPING.put(classId, javaType);
         log.trace("Added mapping for polymorphic deserialization {} <-> {}", classId, javaType);
     }
@@ -97,22 +93,39 @@ public JsonTypeInfo.Id getMechanism() {
         return JsonTypeInfo.Id.CUSTOM;
     }
 
-    @NotNull
     private String getIdFromValue(Object value) {
         if (value == null) {
             log.warn("Should normally never happen, Jackson should handle nulls");
             return "unknown";
         }
 
+        if (value instanceof UnknownClassesContentModelData || value instanceof ListWrapper.UnknownClassesListWrapper) {
+            log.debug("Value {} is of an unknown non-core type, we have no idea about the type, let's just skip it, it is in the data map anyway", value);
+            return null;
+        }
+
         JsonTypeName annotation = value.getClass().getAnnotation(JsonTypeName.class);
         if (annotation != null && !isEmpty(annotation.value())) {
             log.trace("Type ID for value '{}' taken from annotation and is '{}'", value, annotation.value());
             return annotation.value();
         }
 
         if (value instanceof ListWrapper && !((ListWrapper) value).empty()) {
-            String simpleName = ((ListWrapper) value).get(0).getClass().getSimpleName();
-            String id = getMappingName(simpleName) + LIST_MARKER;
+            Object firstValue = ((ListWrapper) value).get(0);
+
+            String typeName;
+            if (firstValue instanceof HandlesTypeInformationForListWrapper) {
+                log.debug("First value of the list defines a type ID for the list", value);
+                typeName = ((HandlesTypeInformationForListWrapper) firstValue).getTypeId();
+            } else if (firstValue.getClass().isAnnotationPresent(JsonTypeName.class)) {
+                log.debug("First value of the list is annotated with a type ID for the list", value);
+                typeName = defaultIfBlank(firstValue.getClass().getAnnotation(JsonTypeName.class).value(),
+                        firstValue.getClass().getSimpleName());
+            } else {
+                log.debug("First value of the list doesn't know a type ID for the list, using simple name", value);
+                typeName = firstValue.getClass().getSimpleName();
+            }
+            String id = getMappingName(typeName) + Constants.LIST_MARKER;
             log.trace("Value is instance of ListWrapper without an explicit implementation, value = '{}', id = '{}'", id);
             return id;
         }
@@ -127,8 +140,13 @@ private String getMappingName(String simpleName) {
     }
 
     @Override
-    public JavaType typeFromId(DatabindContext context, String id) throws IOException {
+    public JavaType typeFromId(DatabindContext context, String id) {
         JavaType javaType = BASIC_MAPPING.get(id);
+        if (javaType == null) {
+            log.debug("Found id = {} which we don't know, create a map or list of maps to just save the data", id);
+            return TypeFactory.defaultInstance().constructSpecializedType(unknownType(),
+                    id.contains(Constants.LIST_MARKER) ? ListWrapper.UnknownClassesListWrapper.class : UnknownClassesContentModelData.class);
+        }
         log.trace("Type ID '{}' is mapped to '{}'", id, javaType);
         return javaType;
     }

dxa-framework/dxa-data-model/src/main/java/com/sdl/dxa/api/datamodel/json/Polymorphic.java

@@ -4,8 +4,10 @@
 import com.sdl.dxa.api.datamodel.DataModelSpringConfiguration;
 
 /**
- * Annotation that marks object as polymorphic.
+ * Annotation that marks object as polymorphic meaning that it may have subclasses.
  * Used by {@link ObjectMapper} to set {@link PolymorphicObjectMixin} in {@link DataModelSpringConfiguration}.
+ *
+ * @dxa.publicApi
  */
 public @interface Polymorphic {
 

dxa-framework/dxa-data-model/src/main/java/com/sdl/dxa/api/datamodel/json/PolymorphicObjectMixin.java

@@ -5,6 +5,8 @@
 import com.fasterxml.jackson.databind.annotation.JsonTypeIdResolver;
 import com.fasterxml.jackson.databind.annotation.JsonTypeResolver;
 
+import static com.sdl.dxa.api.datamodel.json.Constants.DOLLAR_TYPE;
+
 /**
  * Mix-in for Jackson that makes everything polymorphic.
  * <p>To be added to the configuration of {@link ObjectMapper} to make all Java objects polymorphic,
@@ -13,7 +15,7 @@
 @SuppressWarnings("unused")
 @JsonTypeResolver(ModelDataTypeResolver.class)
 @JsonTypeIdResolver(ModelDataTypeIdResolver.class)
-@JsonTypeInfo(use = JsonTypeInfo.Id.CUSTOM, include = JsonTypeInfo.As.PROPERTY, property = "$type")
+@JsonTypeInfo(use = JsonTypeInfo.Id.CUSTOM, include = JsonTypeInfo.As.PROPERTY, property = DOLLAR_TYPE, visible = true)
 public interface PolymorphicObjectMixin {
 
 }

dxa-framework/dxa-data-model/src/main/java/com/sdl/dxa/api/datamodel/model/ContentModelData.java

@@ -8,6 +8,8 @@
 import java.util.HashMap;
 import java.util.Map;
 
+import static com.sdl.dxa.api.datamodel.json.Constants.DOLLAR_TYPE;
+
 /**
  * {@link Map} implemenation to handle DXA polymorphic JSON logic. Is created to be able to address to {@code ContentModelData[]}.
  */
@@ -36,6 +38,24 @@ public ContentModelData(ContentModelData other) {
     }
     //endregion
 
+    @Override
+    public Object put(String key, Object value) {
+        return shouldRemoveDollarType() && DOLLAR_TYPE.equals(key) ? null : super.put(key, value);
+    }
+
+    @Override
+    public void putAll(Map<? extends String, ?> m) {
+        if (shouldRemoveDollarType()) {
+            m.remove(DOLLAR_TYPE);
+        }
+        super.putAll(m);
+    }
+
+    @Override
+    public Object putIfAbsent(String key, Object value) {
+        return shouldRemoveDollarType() && DOLLAR_TYPE.equals(key) ? null : super.putIfAbsent(key, value);
+    }
+
     @Override
     public Object getElement(String identifier) {
         return get(identifier);
@@ -60,4 +80,13 @@ public Object getWrappedModel() {
             }
         };
     }
+
+    /**
+     * $type is removed only for unknown classes which are mapped to a a map.
+     *
+     * @return true unless overridden
+     */
+    protected boolean shouldRemoveDollarType() {
+        return true;
+    }
 }

dxa-framework/dxa-data-model/src/main/java/com/sdl/dxa/api/datamodel/model/PageModelData.java

@@ -1,7 +1,6 @@
 package com.sdl.dxa.api.datamodel.model;
 
 import com.fasterxml.jackson.annotation.JsonTypeName;
-import com.sdl.dxa.api.datamodel.model.condition.Condition;
 import com.sdl.dxa.api.datamodel.model.util.ModelDataWrapper;
 import lombok.AllArgsConstructor;
 import lombok.Data;
@@ -32,8 +31,6 @@ public class PageModelData extends ViewModelData {
 
     private List<RegionModelData> regions;
 
-    private List<Condition> conditions;
-
     private String urlPath;
 
     @Override

dxa-framework/dxa-data-model/src/main/java/com/sdl/dxa/api/datamodel/model/util/HandlesTypeInformationForListWrapper.java

@@ -0,0 +1,28 @@
+package com.sdl.dxa.api.datamodel.model.util;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.sdl.dxa.api.datamodel.json.Polymorphic;
+
+/**
+ * If you have a parent class and its children, and you have a {@code ListWrapper}<{@code ParentClass}> with
+ * any children type expected inside the list, then we cannot guess the generic type of the list because generics in Java
+ * are removed in runtime. If we simply guess the generic type by the first element, we may be wrong.
+ * <p>To handle this we need this interface. It should be implemented by parent class of the parent-children hierarchy.
+ * When we need to get a type of the whole list, the first element will be checked for this, and if the parent implements
+ * this, then we will get a list of parents.</p>
+ * <p>A parent should also implement {@link Polymorphic}, so we know it is a parent and not a concrete class. By the way,
+ * it cannot be abstract or interface. Sorry about this.</p>
+ *
+ * @dxa.publicApi
+ */
+@FunctionalInterface
+public interface HandlesTypeInformationForListWrapper {
+
+    /**
+     * Returns {@code Type ID} of the implementor. Implement on parent (top level) classes.
+     *
+     * @return type id
+     */
+    @JsonIgnore
+    String getTypeId();
+}

dxa-framework/dxa-data-model/src/main/java/com/sdl/dxa/api/datamodel/model/util/ListWrapper.java

@@ -8,12 +8,15 @@
 import com.sdl.dxa.api.datamodel.model.RichTextData;
 import lombok.AccessLevel;
 import lombok.Data;
+import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 
 import java.util.ArrayList;
 import java.util.List;
 
+import static com.sdl.dxa.api.datamodel.json.Constants.DOLLAR_TYPE;
+
 /**
  * Wrapper for the polymorphic list JSON representation coming from .NET Template Builder.
  * <p>It serializes the list as the following meaning that all elements of a list are of type {@link ContentModelData}</p>
@@ -96,4 +99,20 @@ public RichTextDataListWrapper(List<RichTextData> values) {
             super(values);
         }
     }
+
+    /**
+     * List of unknown entity-level {@link UnknownClassesContentModelData}s.
+     */
+    @NoArgsConstructor(access = AccessLevel.PUBLIC)
+    public static class UnknownClassesListWrapper extends ListWrapper<UnknownClassesContentModelData> {
+
+        @JsonProperty(DOLLAR_TYPE)
+        @Getter
+        private String type;
+
+        @SuppressWarnings("unused")
+        public UnknownClassesListWrapper(List<UnknownClassesContentModelData> values) {
+            super(values);
+        }
+    }
 }