Introduce @AutoTimestamp annotation

Author: codeconsole

grails-datastore-core/src/main/groovy/org/grails/datastore/mapping/config/Entity.groovy

@@ -56,8 +56,6 @@ class Entity<P extends Property> {
      * @return Whether automatic time stamps should be applied to 'lastUpdate' and 'dateCreated' properties
      */
     boolean autoTimestamp = true
-    String dateCreated = null
-    String lastUpdated = null
 
     /**
      * @return Whether the entity should be autowired

grails-datastore-gorm-tck/src/main/groovy/grails/gorm/tests/CustomAutotimeStampSpec.groovy renamed to grails-datastore-gorm-test/src/test/groovy/org/grails/datastore/gorm/CustomAutoTimestampSpec.groovy

@@ -1,13 +1,15 @@
-package grails.gorm.tests
+package org.grails.datastore.gorm
 
+import grails.gorm.annotation.AutoTimestamp
+import grails.gorm.tests.GormDatastoreSpec
 import grails.persistence.Entity
 
-class CustomAutotimeStampSpec extends GormDatastoreSpec{
+class CustomAutoTimestampSpec extends GormDatastoreSpec {
 
     void "Test when the auto timestamp properties are customized, they are correctly set"() {
         when:"An entity is persisted"
             def r = new RecordCustom(name: "Test")
-            r.save(flush:true)
+            r.save(flush:true, failOnError:true)
             session.clear()
             r = RecordCustom.get(r.id)
 
@@ -23,8 +25,8 @@ class CustomAutotimeStampSpec extends GormDatastoreSpec{
             session.clear()
             r = RecordCustom.get(r.id)
 
-        then:"the custom lastUpdated property is updated and dateCreated is not"
-            r.modified != null && previousModified > r.modified
+            then:"the custom lastUpdated property is updated and dateCreated is not"
+            r.modified != null && previousModified < r.modified
             previousCreated == r.created
     }
     @Override
@@ -37,11 +39,6 @@ class CustomAutotimeStampSpec extends GormDatastoreSpec{
 class RecordCustom {
     Long id
     String name
-    Date created
-    Date modified
-
-    static mapping = {
-        dateCreated 'created'
-        lastUpdated 'modified'
-    }
+    @AutoTimestamp(false) Date created
+    @AutoTimestamp Date modified
 }

grails-datastore-gorm/src/main/groovy/grails/gorm/annotation/AutoTimestamp.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2024 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package grails.gorm.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * A property annotation used to enable automatic updates to time objects
+ * upon gorm modification events
+ *
+ * @author Scott Murphy Heiberg
+ * @since 7.0
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD})
+public @interface AutoTimestamp {
+    /**
+     * A qualifier boolean value that represents if update events
+     * should be updated as well. Setting value to false only updates on creation events.
+     */
+    boolean value() default true;
+}

grails-datastore-gorm/src/main/groovy/org/grails/datastore/gorm/events/AutoTimestampEventListener.java

@@ -14,10 +14,12 @@
  */
 package org.grails.datastore.gorm.events;
 
+import java.lang.reflect.Field;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
 
+import grails.gorm.annotation.AutoTimestamp;
 import org.grails.datastore.gorm.timestamp.DefaultTimestampProvider;
 import org.grails.datastore.gorm.timestamp.TimestampProvider;
 import org.grails.datastore.mapping.config.Entity;
@@ -45,13 +47,11 @@ public class AutoTimestampEventListener extends AbstractPersistenceEventListener
     public static final String DATE_CREATED_PROPERTY = "dateCreated";
     public static final String LAST_UPDATED_PROPERTY = "lastUpdated";
 
-    protected Map<String, String> entitiesWithDateCreated = new ConcurrentHashMap<>();
-    protected Map<String, String> entitiesWithLastUpdated = new ConcurrentHashMap<>();
+    protected Map<String, Set<String>> entitiesWithDateCreated = new ConcurrentHashMap<>();
+    protected Map<String, Set<String>> entitiesWithLastUpdated = new ConcurrentHashMap<>();
     protected Collection<String> uninitializedEntities = new ConcurrentLinkedQueue<>();
-    
-    
+
     private TimestampProvider timestampProvider = new DefaultTimestampProvider();
-    
 
     public AutoTimestampEventListener(final Datastore datastore) {
         super(datastore);
@@ -95,19 +95,23 @@ public boolean beforeInsert(PersistentEntity entity, EntityAccess ea) {
         initializeIfNecessary(entity, name);
         Class<?> dateCreatedType = null;
         Object timestamp = null;
-        String prop = getDateCreatedPropertyName(name);
-        if (prop != null) {
-            dateCreatedType = ea.getPropertyType(prop);
-            timestamp = timestampProvider.createTimestamp(dateCreatedType);
-            ea.setProperty(prop, timestamp);
+        Set<String> props = getDateCreatedPropertyNames(name);
+        if (props != null) {
+            for (String prop : props) {
+                dateCreatedType = ea.getPropertyType(prop);
+                timestamp = timestampProvider.createTimestamp(dateCreatedType);
+                ea.setProperty(prop, timestamp);
+            }
         }
-        prop = getLastUpdatedPropertyName(name);
-        if (prop != null) {
-            Class<?> lastUpdateType = ea.getPropertyType(prop);
-            if (dateCreatedType == null || !lastUpdateType.isAssignableFrom(dateCreatedType)) {
-                timestamp = timestampProvider.createTimestamp(lastUpdateType);
+        props = getLastUpdatedPropertyNames(name);
+        if (props != null) {
+            for (String prop : props) {
+                Class<?> lastUpdateType = ea.getPropertyType(prop);
+                if (dateCreatedType == null || !lastUpdateType.isAssignableFrom(dateCreatedType)) {
+                    timestamp = timestampProvider.createTimestamp(lastUpdateType);
+                }
+                ea.setProperty(prop, timestamp);
             }
-            ea.setProperty(prop, timestamp);
         }
         return true;
     }
@@ -120,43 +124,70 @@ private void initializeIfNecessary(PersistentEntity entity, String name) {
     }
 
     public boolean beforeUpdate(PersistentEntity entity, EntityAccess ea) {
-        String prop = getLastUpdatedPropertyName(entity.getName());
-        if (prop != null) {
-            Class<?> lastUpdateType = ea.getPropertyType(prop);
-            Object timestamp = timestampProvider.createTimestamp(lastUpdateType);
-            ea.setProperty(prop, timestamp);
+        Set<String> props = getLastUpdatedPropertyNames(entity.getName());
+        if (props != null) {
+            for (String prop : props) {
+                Class<?> lastUpdateType = ea.getPropertyType(prop);
+                Object timestamp = timestampProvider.createTimestamp(lastUpdateType);
+                ea.setProperty(prop, timestamp);
+            }
         }
         return true;
     }
 
-    protected String getLastUpdatedPropertyName(String n) {
-        return entitiesWithLastUpdated.get(n);
+    protected Set<String> getLastUpdatedPropertyNames(String entityName) {
+        return entitiesWithLastUpdated.get(entityName);
     }
 
-    protected String getDateCreatedPropertyName(String n) {
-        return entitiesWithDateCreated.get(n);
+    protected Set<String> getDateCreatedPropertyNames(String entityName) {
+        return entitiesWithDateCreated.get(entityName);
+    }
+
+    private static Field getFieldFromHierarchy(PersistentEntity persistentEntity, String fieldName) {
+        Class<?> clazz = persistentEntity.getJavaClass();
+        while (clazz != null) {
+            try {
+                return clazz.getDeclaredField(fieldName);
+            } catch (NoSuchFieldException e) {
+                persistentEntity = persistentEntity.getParentEntity();
+                clazz = persistentEntity == null? null : persistentEntity.getJavaClass();
+            }
+        }
+        return null;
     }
 
     protected void storeDateCreatedAndLastUpdatedInfo(PersistentEntity persistentEntity) {
         if (persistentEntity.isInitialized()) {
             ClassMapping<?> classMapping = persistentEntity.getMapping();
-            Entity mappedForm = classMapping.getMappedForm();
+            Entity<?> mappedForm = classMapping.getMappedForm();
             if (mappedForm == null || mappedForm.isAutoTimestamp()) {
-                storeTimestampAvailability(entitiesWithDateCreated, persistentEntity,
-                        persistentEntity.getPropertyByName(mappedForm.getDateCreated() != null?
-                                mappedForm.getDateCreated() : DATE_CREATED_PROPERTY));
-                storeTimestampAvailability(entitiesWithLastUpdated, persistentEntity,
-                        persistentEntity.getPropertyByName(mappedForm.getLastUpdated() != null?
-                                mappedForm.getLastUpdated() : LAST_UPDATED_PROPERTY));
+                for (PersistentProperty<?> property : persistentEntity.getPersistentProperties()) {
+                    if (property.getName().equals(LAST_UPDATED_PROPERTY)) {
+                        storeTimestampAvailability(entitiesWithLastUpdated, persistentEntity, property);
+                    } else if (property.getName().equals(DATE_CREATED_PROPERTY)) {
+                        storeTimestampAvailability(entitiesWithDateCreated, persistentEntity, property);
+                    } else {
+                        Field field = getFieldFromHierarchy(persistentEntity, property.getName());
+                        if (field != null && field.isAnnotationPresent(AutoTimestamp.class)) {
+                            AutoTimestamp autoTimestamp = field.getAnnotation(AutoTimestamp.class);
+                            if (autoTimestamp.value()) {
+                                storeTimestampAvailability(entitiesWithLastUpdated, persistentEntity, property);
+                            } else {
+                                storeTimestampAvailability(entitiesWithDateCreated, persistentEntity, property);
+                            }
+                        }
+                    }
+                }
             }
         } else {
             uninitializedEntities.add(persistentEntity.getName());
         }
     }
 
-    protected void storeTimestampAvailability(Map<String, String> timestampAvailabilityMap, PersistentEntity persistentEntity, PersistentProperty<?> property) {
+    protected void storeTimestampAvailability(Map<String, Set<String>> timestampAvailabilityMap, PersistentEntity persistentEntity, PersistentProperty<?> property) {
         if (property != null && timestampProvider.supportsCreating(property.getType())) {
-            timestampAvailabilityMap.put(persistentEntity.getName(), property.getName());
+            Set<String> timestampProperties = timestampAvailabilityMap.computeIfAbsent(persistentEntity.getName(), k -> new HashSet<>());
+            timestampProperties.add(property.getName());
         }
     }
 
@@ -172,25 +203,25 @@ public void setTimestampProvider(TimestampProvider timestampProvider) {
         this.timestampProvider = timestampProvider;
     }
 
-    private void processAllEntries(final Set<Map.Entry<String, String>> entries, final Runnable runnable)  {
-        Map<String, String> originalValues = new LinkedHashMap<>();
-        for (Map.Entry<String, String> entry: entries) {
+    private void processAllEntries(final Set<Map.Entry<String, Set<String>>> entries, final Runnable runnable)  {
+        Map<String, Set<String>> originalValues = new LinkedHashMap<>();
+        for (Map.Entry<String, Set<String>> entry: entries) {
             originalValues.put(entry.getKey(), entry.getValue());
             entry.setValue(null);
         }
         runnable.run();
-        for (Map.Entry<String, String> entry: entries) {
+        for (Map.Entry<String, Set<String>> entry: entries) {
             entry.setValue(originalValues.get(entry.getKey()));
         }
     }
 
-    private void processEntries(final List<Class> classes, Map<String, String> entities, final Runnable runnable) {
-        Set<Map.Entry<String, String>> entries = new HashSet<>();
+    private void processEntries(final List<Class> classes, Map<String, Set<String>> entities, final Runnable runnable) {
+        Set<Map.Entry<String, Set<String>>> entries = new HashSet<>();
         final List<String> classNames = new ArrayList<>(classes.size());
         for (Class clazz: classes) {
             classNames.add(clazz.getName());
         }
-        for (Map.Entry<String, String> entry: entities.entrySet()) {
+        for (Map.Entry<String, Set<String>> entry: entities.entrySet()) {
             if (classNames.contains(entry.getKey())) {
                 entries.add(entry);
             }