You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@isis.apache.org by ah...@apache.org on 2021/07/26 19:29:35 UTC
[isis] 01/01: ISIS-2826: don't require JPA to implement the heavy
weight EntityChangeTracking
This is an automated email from the ASF dual-hosted git repository.
ahuber pushed a commit to branch 2826-lightw.prop.ch.tr
in repository https://gitbox.apache.org/repos/asf/isis.git
commit f2f1c2855023aad7104fbe3e330acc0358dd9701
Author: Andi Huber <ah...@apache.org>
AuthorDate: Mon Jul 26 21:29:10 2021 +0200
ISIS-2826: don't require JPA to implement the heavy weight
EntityChangeTracking
provide an ad-hoc on the fly alternative
---
.../transaction/IsisModuleCoreTransaction.java | 3 +-
.../PersistenceCallbackHandlerAbstract.java | 61 +++++
...{_PreAndPostValue.java => PreAndPostValue.java} | 16 +-
...hPreValue.java => PropertyChangePublisher.java} | 34 ++-
...ChangeRecord.java => PropertyChangeRecord.java} | 32 ++-
.../PreAndPostValues_shouldAudit_Test.java | 10 +-
.../jdo/integration/IsisModuleJdoIntegration.java | 5 +-
.../changetracking/EntityChangeTrackerJdo.java | 129 ++--------
.../changetracking/_ChangingEntitiesFactory.java | 4 +-
.../_EntityPropertyChangeFactory.java | 5 +-
.../changetracking/_SimpleChangingEntities.java | 2 +-
.../jdo/integration}/changetracking/_Xray.java | 4 +-
.../jpa/applib/integration/IsisEntityListener.java | 74 +++---
.../jpa/integration/IsisModuleJpaIntegration.java | 2 +
.../changetracking/PropertyChangePublisherJpa.java | 262 +++++++++++++++++++++
.../publishing/jpa/JpaEntityPublishingTest.java | 2 +
.../publishing/PublishingTestFactoryAbstract.java | 12 +-
17 files changed, 476 insertions(+), 181 deletions(-)
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/IsisModuleCoreTransaction.java b/core/transaction/src/main/java/org/apache/isis/core/transaction/IsisModuleCoreTransaction.java
index 11b6e66..dd25c15 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/IsisModuleCoreTransaction.java
+++ b/core/transaction/src/main/java/org/apache/isis/core/transaction/IsisModuleCoreTransaction.java
@@ -21,14 +21,13 @@ package org.apache.isis.core.transaction;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
-import org.apache.isis.core.transaction.changetracking.EntityChangeTrackerDefault;
import org.apache.isis.core.transaction.changetracking.events.TimestampService;
@Configuration
@Import({
// @Service's
TimestampService.class,
- EntityChangeTrackerDefault.class,
+
})
public class IsisModuleCoreTransaction {
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PersistenceCallbackHandlerAbstract.java b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PersistenceCallbackHandlerAbstract.java
new file mode 100644
index 0000000..88f17fc
--- /dev/null
+++ b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PersistenceCallbackHandlerAbstract.java
@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.isis.core.transaction.changetracking;
+
+import org.apache.isis.applib.events.lifecycle.AbstractLifecycleEvent;
+import org.apache.isis.applib.services.eventbus.EventBusService;
+import org.apache.isis.commons.internal.factory._InstanceUtil;
+import org.apache.isis.core.metamodel.facets.object.callbacks.LifecycleEventFacet;
+import org.apache.isis.core.metamodel.spec.ManagedObject;
+
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.val;
+
+@RequiredArgsConstructor(access = AccessLevel.PROTECTED)
+public abstract class PersistenceCallbackHandlerAbstract {
+
+ protected final EventBusService eventBusService;
+
+ // -- HELPER
+
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ protected void postLifecycleEventIfRequired(
+ final ManagedObject adapter,
+ final Class<? extends LifecycleEventFacet> lifecycleEventFacetClass) {
+
+ val lifecycleEventFacet = adapter.getSpecification().getFacet(lifecycleEventFacetClass);
+ if(lifecycleEventFacet == null) {
+ return;
+ }
+ val eventInstance = (AbstractLifecycleEvent) _InstanceUtil
+ .createInstance(lifecycleEventFacet.getEventType());
+ val pojo = adapter.getPojo();
+ postEvent(eventInstance, pojo);
+
+ }
+
+ protected void postEvent(final AbstractLifecycleEvent<Object> event, final Object pojo) {
+ if(eventBusService!=null) {
+ event.initSource(pojo);
+ eventBusService.post(event);
+ }
+ }
+
+}
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_PreAndPostValue.java b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PreAndPostValue.java
similarity index 86%
rename from core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_PreAndPostValue.java
rename to core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PreAndPostValue.java
index 8a103ec..5a284d5 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_PreAndPostValue.java
+++ b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PreAndPostValue.java
@@ -24,7 +24,7 @@ import org.apache.isis.core.transaction.changetracking.events.IsisTransactionPla
import lombok.Getter;
-final class _PreAndPostValue {
+public final class PreAndPostValue {
/**
* The object that was referenced before this object was changed.
@@ -44,26 +44,26 @@ final class _PreAndPostValue {
@Getter private final Object post;
@Getter private final String postString;
- public static _PreAndPostValue pre(final Object preValue) {
- return new _PreAndPostValue(preValue);
+ public static PreAndPostValue pre(final Object preValue) {
+ return new PreAndPostValue(preValue);
}
- private _PreAndPostValue(final Object pre) {
+ private PreAndPostValue(final Object pre) {
this.pre = pre;
this.preString = asString(pre);
this.post = null;
this.postString = null;
}
- private _PreAndPostValue(final _PreAndPostValue pre, final Object post) {
+ private PreAndPostValue(final PreAndPostValue pre, final Object post) {
this.pre = pre.getPre();
this.preString = pre.getPreString();
this.post = post;
this.postString = asString(post);
}
- public _PreAndPostValue withPost(final Object post) {
- return new _PreAndPostValue(this, post);
+ public PreAndPostValue withPost(final Object post) {
+ return new PreAndPostValue(this, post);
}
@Override
@@ -88,7 +88,7 @@ final class _PreAndPostValue {
// -- HELPER
- private static String asString(Object object) {
+ private static String asString(final Object object) {
return object != null
? object.toString()
: null;
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerWithPreValue.java b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PropertyChangePublisher.java
similarity index 56%
rename from core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerWithPreValue.java
rename to core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PropertyChangePublisher.java
index 9efdbca..bcc0388 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerWithPreValue.java
+++ b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PropertyChangePublisher.java
@@ -18,26 +18,38 @@
*/
package org.apache.isis.core.transaction.changetracking;
+import org.apache.isis.commons.collections.Can;
import org.apache.isis.core.metamodel.spec.ManagedObject;
/**
- * @since 2 {@index}
+ * Responsible for collecting then immediately publishing changes to domain objects
+ * within a transaction, that is, notify publishing subscribers and call the various
+ * persistence call-back facets.
+ *
+ * @since 2.0 {index}
+ * @apiNote Introduced for JPA (EclipseLink implementation). More lightweight than
+ * {@link EntityChangeTracker}
*/
-public interface EntityChangeTrackerWithPreValue extends EntityChangeTracker {
+public interface PropertyChangePublisher {
/**
- * An override of {@link EntityChangeTracker#enlistUpdating(ManagedObject)}
+ * TODO update ... An override of {@link EntityChangeTracker#enlistUpdating(ManagedObject)}
* where the caller already knows the old value (and so the
* {@link EntityChangeTracker} does not need to capture the old value itself.
*
- * <p>
- * Introduced for JPA (EclipseLink implementation).
- * </p>
- *
* @param entity - being enlisted
- * @param propertyIdIfAny - the entity property id (its simple name); if non-null, indicates that the pre value is known
- * @param preValue - the pre-value (could be null); only relevant if propertyNameIfAny is provided (non-null).
+ * @param preValue - the pre-value (could be null)
*/
- void enlistUpdating(ManagedObject entity, String propertyIdIfAny, Object preValue);
-}
+ void onPreUpdate(ManagedObject entity, Can<PropertyChangeRecord> changeRecords);
+
+ void onPrePersist(ManagedObject entity);
+
+ void onPreRemove(ManagedObject entity);
+ void onPostPersist(ManagedObject entity);
+
+ void onPostUpdate(ManagedObject entity);
+
+ void onPostRemove(ManagedObject entity);
+
+}
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_PropertyChangeRecord.java b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PropertyChangeRecord.java
similarity index 73%
rename from core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_PropertyChangeRecord.java
rename to core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PropertyChangeRecord.java
index 7d37fb4..0210430 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_PropertyChangeRecord.java
+++ b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PropertyChangeRecord.java
@@ -32,47 +32,59 @@ import lombok.NonNull;
import lombok.ToString;
import lombok.val;
-
@EqualsAndHashCode(of = {"bookmarkStr", "propertyId"})
@ToString(of = {"bookmarkStr", "propertyId"})
-final class _PropertyChangeRecord {
+public final class PropertyChangeRecord {
@Getter private final ManagedObject entity;
@Getter private final ObjectAssociation property;
@Getter private final Bookmark bookmark;
@Getter private final String propertyId;
- @Getter private _PreAndPostValue preAndPostValue;
+ @Getter private PreAndPostValue preAndPostValue;
private final String bookmarkStr;
- public static _PropertyChangeRecord of(
+ public static PropertyChangeRecord of(
final @NonNull ManagedObject entity,
final @NonNull ObjectAssociation property) {
- return new _PropertyChangeRecord(entity, property);
+ return new PropertyChangeRecord(entity, property, null);
}
- private _PropertyChangeRecord(final ManagedObject entity, final ObjectAssociation property) {
+ public static PropertyChangeRecord of(
+ final @NonNull ManagedObject entity,
+ final @NonNull ObjectAssociation property,
+ final @NonNull PreAndPostValue preAndPostValue) {
+ return new PropertyChangeRecord(entity, property, preAndPostValue);
+ }
+
+ private PropertyChangeRecord(
+ final ManagedObject entity,
+ final ObjectAssociation property,
+ final PreAndPostValue preAndPostValue) {
this.entity = entity;
this.property = property;
this.propertyId = property.getId();
this.bookmark = ManagedObjects.bookmarkElseFail(entity);
this.bookmarkStr = bookmark.toString();
+
+ this.preAndPostValue = preAndPostValue;
}
public String getMemberId() {
return property.getFeatureIdentifier().getFullIdentityString();
}
- void setPreValue(final Object pre) {
- preAndPostValue = _PreAndPostValue.pre(pre);
+ public void setPreValue(final Object pre) {
+ preAndPostValue = PreAndPostValue.pre(pre);
}
- void updatePreValue() {
+ public void updatePreValue() {
setPreValue(getPropertyValue());
}
- void updatePostValue(/*final boolean isEntityDeleted*/) {
+ @Deprecated // unreliable logic, instead the caller should know if this originates from a delete event
+ public void updatePostValue() {
preAndPostValue = EntityUtil.isDetachedOrRemoved(entity) //TODO[ISIS-2573] when detached, logic is wrong
? preAndPostValue.withPost(IsisTransactionPlaceholder.DELETED)
: preAndPostValue.withPost(getPropertyValue());
diff --git a/core/transaction/src/test/java/org/apache/isis/core/transaction/changetracking/PreAndPostValues_shouldAudit_Test.java b/core/transaction/src/test/java/org/apache/isis/core/transaction/changetracking/PreAndPostValues_shouldAudit_Test.java
index 9d6bc7a..554ab1b 100644
--- a/core/transaction/src/test/java/org/apache/isis/core/transaction/changetracking/PreAndPostValues_shouldAudit_Test.java
+++ b/core/transaction/src/test/java/org/apache/isis/core/transaction/changetracking/PreAndPostValues_shouldAudit_Test.java
@@ -32,35 +32,35 @@ public class PreAndPostValues_shouldAudit_Test {
@Test
public void just_created() {
- val preAndPostValue = _PreAndPostValue.pre(IsisTransactionPlaceholder.NEW)
+ val preAndPostValue = PreAndPostValue.pre(IsisTransactionPlaceholder.NEW)
.withPost("Foo");
assertTrue(preAndPostValue.shouldPublish());
}
@Test
public void just_deleted() {
- val preAndPostValue = _PreAndPostValue.pre("Foo")
+ val preAndPostValue = PreAndPostValue.pre("Foo")
.withPost(IsisTransactionPlaceholder.DELETED);
assertTrue(preAndPostValue.shouldPublish());
}
@Test
public void changed() {
- val preAndPostValue = _PreAndPostValue.pre("Foo")
+ val preAndPostValue = PreAndPostValue.pre("Foo")
.withPost("Bar");
assertTrue(preAndPostValue.shouldPublish());
}
@Test
public void unchanged() {
- val preAndPostValue = _PreAndPostValue.pre("Foo")
+ val preAndPostValue = PreAndPostValue.pre("Foo")
.withPost("Foo");
assertFalse(preAndPostValue.shouldPublish());
}
@Test
public void created_and_then_deleted() {
- val preAndPostValue = _PreAndPostValue.pre(IsisTransactionPlaceholder.NEW)
+ val preAndPostValue = PreAndPostValue.pre(IsisTransactionPlaceholder.NEW)
.withPost(IsisTransactionPlaceholder.DELETED);
assertFalse(preAndPostValue.shouldPublish());
diff --git a/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/IsisModuleJdoIntegration.java b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/IsisModuleJdoIntegration.java
index 0dab814..9e1718b 100644
--- a/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/IsisModuleJdoIntegration.java
+++ b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/IsisModuleJdoIntegration.java
@@ -23,6 +23,7 @@ import org.springframework.context.annotation.Import;
import org.apache.isis.core.runtime.IsisModuleCoreRuntime;
import org.apache.isis.persistence.jdo.applib.IsisModulePersistenceJdoApplib;
+import org.apache.isis.persistence.jdo.integration.changetracking.EntityChangeTrackerJdo;
import org.apache.isis.persistence.jdo.metamodel.IsisModuleJdoMetamodel;
@Configuration
@@ -32,9 +33,9 @@ import org.apache.isis.persistence.jdo.metamodel.IsisModuleJdoMetamodel;
IsisModulePersistenceJdoApplib.class,
IsisModuleJdoMetamodel.class,
+ // services
+ EntityChangeTrackerJdo.class,
})
public class IsisModuleJdoIntegration {
-
-
}
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerDefault.java b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/EntityChangeTrackerJdo.java
similarity index 77%
rename from core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerDefault.java
rename to persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/EntityChangeTrackerJdo.java
index db80a68..a43e1f0 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerDefault.java
+++ b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/EntityChangeTrackerJdo.java
@@ -16,7 +16,7 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.apache.isis.core.transaction.changetracking;
+package org.apache.isis.persistence.jdo.integration.changetracking;
import java.util.Map;
import java.util.Optional;
@@ -25,8 +25,6 @@ import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.LongAdder;
import java.util.function.Consumer;
-import javax.annotation.PostConstruct;
-import javax.annotation.PreDestroy;
import javax.annotation.Priority;
import javax.inject.Inject;
import javax.inject.Named;
@@ -40,7 +38,6 @@ import org.springframework.stereotype.Service;
import org.apache.isis.applib.annotation.EntityChangeKind;
import org.apache.isis.applib.annotation.InteractionScope;
import org.apache.isis.applib.annotation.PriorityPrecedence;
-import org.apache.isis.applib.events.lifecycle.AbstractLifecycleEvent;
import org.apache.isis.applib.services.bookmark.Bookmark;
import org.apache.isis.applib.services.eventbus.EventBusService;
import org.apache.isis.applib.services.iactn.Interaction;
@@ -54,9 +51,7 @@ import org.apache.isis.commons.internal.base._Lazy;
import org.apache.isis.commons.internal.collections._Maps;
import org.apache.isis.commons.internal.collections._Sets;
import org.apache.isis.commons.internal.exceptions._Exceptions;
-import org.apache.isis.commons.internal.factory._InstanceUtil;
import org.apache.isis.core.metamodel.facets.object.callbacks.CallbackFacet;
-import org.apache.isis.core.metamodel.facets.object.callbacks.LifecycleEventFacet;
import org.apache.isis.core.metamodel.facets.object.callbacks.LoadedCallbackFacet;
import org.apache.isis.core.metamodel.facets.object.callbacks.LoadedLifecycleEventFacet;
import org.apache.isis.core.metamodel.facets.object.callbacks.PersistedCallbackFacet;
@@ -73,6 +68,13 @@ import org.apache.isis.core.metamodel.facets.object.publish.entitychange.EntityC
import org.apache.isis.core.metamodel.spec.ManagedObject;
import org.apache.isis.core.metamodel.spec.ManagedObjects;
import org.apache.isis.core.metamodel.spec.feature.MixedIn;
+import org.apache.isis.core.transaction.changetracking.EntityChangeTracker;
+import org.apache.isis.core.transaction.changetracking.EntityChangesPublisher;
+import org.apache.isis.core.transaction.changetracking.EntityPropertyChangePublisher;
+import org.apache.isis.core.transaction.changetracking.HasEnlistedEntityChanges;
+import org.apache.isis.core.transaction.changetracking.HasEnlistedEntityPropertyChanges;
+import org.apache.isis.core.transaction.changetracking.PersistenceCallbackHandlerAbstract;
+import org.apache.isis.core.transaction.changetracking.PropertyChangeRecord;
import org.apache.isis.core.transaction.changetracking.events.IsisTransactionPlaceholder;
import org.apache.isis.core.transaction.events.TransactionBeforeCompletionEvent;
@@ -86,29 +88,29 @@ import lombok.extern.log4j.Log4j2;
* @since 2.0 {@index}
*/
@Service
-@Named("isis.transaction.EntityChangeTrackerDefault")
+@Named("isis.transaction.EntityChangeTrackerJdo")
@Priority(PriorityPrecedence.EARLY)
-@Qualifier("Default")
+@Qualifier("jdo")
@InteractionScope
@Log4j2
-public class EntityChangeTrackerDefault
+public class EntityChangeTrackerJdo
+extends PersistenceCallbackHandlerAbstract
implements
MetricsService,
- EntityChangeTrackerWithPreValue,
+ EntityChangeTracker,
HasEnlistedEntityPropertyChanges,
HasEnlistedEntityChanges {
-
/**
* Contains initial change records having set the pre-values of every property of every object that was enlisted.
*/
- private final Map<String,_PropertyChangeRecord> propertyChangeRecordsById = _Maps.newLinkedHashMap();
+ private final Map<String,PropertyChangeRecord> propertyChangeRecordsById = _Maps.newLinkedHashMap();
/**
* Contains pre- and post- values of every property of every object that actually changed. A lazy snapshot,
* triggered by internal call to {@link #snapshotPropertyChangeRecords()}.
*/
- private final _Lazy<Set<_PropertyChangeRecord>> entityPropertyChangeRecordsForPublishing
+ private final _Lazy<Set<PropertyChangeRecord>> entityPropertyChangeRecordsForPublishing
= _Lazy.threadSafe(this::capturePostValuesAndDrain);
@Getter(AccessLevel.PACKAGE)
@@ -116,27 +118,16 @@ implements
private final EntityPropertyChangePublisher entityPropertyChangePublisher;
private final EntityChangesPublisher entityChangesPublisher;
- private final EventBusService eventBusService;
private final Provider<InteractionProvider> interactionProviderProvider;
@Inject
- public EntityChangeTrackerDefault(final EntityPropertyChangePublisher entityPropertyChangePublisher, final EntityChangesPublisher entityChangesPublisher, final EventBusService eventBusService, final Provider<InteractionProvider> interactionProviderProvider) {
+ public EntityChangeTrackerJdo(final EntityPropertyChangePublisher entityPropertyChangePublisher, final EntityChangesPublisher entityChangesPublisher, final EventBusService eventBusService, final Provider<InteractionProvider> interactionProviderProvider) {
+ super(eventBusService);
this.entityPropertyChangePublisher = entityPropertyChangePublisher;
this.entityChangesPublisher = entityChangesPublisher;
- this.eventBusService = eventBusService;
this.interactionProviderProvider = interactionProviderProvider;
}
- @PostConstruct
- public void postConstruct() {
-
- }
-
- @PreDestroy
- public void preDestroy() {
-
- }
-
private boolean isEnlisted(final @NonNull ManagedObject adapter) {
return ManagedObjects.bookmark(adapter)
.map(changeKindByEnlistedAdapter::containsKey)
@@ -152,22 +143,12 @@ implements
}
private void enlistUpdatingInternal(
- final @NonNull ManagedObject entity,
- final String propertyIdIfAny,
- final Object preValue) {
+ final @NonNull ManagedObject entity) {
if(!isEntityEnabledForChangePublishing(entity)) {
return;
}
enlistForChangeKindPublishing(entity, EntityChangeKind.UPDATE);
-
- if(propertyIdIfAny != null) {
- // if we've been provided with the property that changed and its pre-value,
- // then just save it in the appropriate PropertyChangeRecord
- enlistForPreAndPostValuePublishing(entity, propertyIdIfAny, preValue);
- } else {
- // read all persistent property pre-values from the pojo using the Isis MM.
- enlistForPreAndPostValuePublishing(entity, _PropertyChangeRecord::updatePreValue);
- }
+ enlistForPreAndPostValuePublishing(entity, PropertyChangeRecord::updatePreValue);
}
private void enlistDeletingInternal(final @NonNull ManagedObject adapter) {
@@ -176,11 +157,11 @@ implements
}
final boolean enlisted = enlistForChangeKindPublishing(adapter, EntityChangeKind.DELETE);
if(enlisted) {
- enlistForPreAndPostValuePublishing(adapter, _PropertyChangeRecord::updatePreValue);
+ enlistForPreAndPostValuePublishing(adapter, PropertyChangeRecord::updatePreValue);
}
}
- Set<_PropertyChangeRecord> snapshotPropertyChangeRecords() {
+ Set<PropertyChangeRecord> snapshotPropertyChangeRecords() {
// this code path has side-effects, it locks the result for this transaction,
// such that cannot enlist on top of it
return entityPropertyChangeRecordsForPublishing.get();
@@ -308,42 +289,15 @@ implements
return previousChangeKind == null;
}
-
- /**
- * Variant of {@link #enlistForPreAndPostValuePublishing(ManagedObject, Consumer)},
- * where we know the changed property and its pre-value in advance (JPA)
- */
- private void enlistForPreAndPostValuePublishing(
- final ManagedObject entity,
- final String propertyId,
- final Object preValue) {
-
- if(propertyChangeRecordsById.containsKey(propertyId)) {
- return;
- }
-
- log.debug("enlist entity's single property change ({}) for publishing {}", propertyId, entity);
-
- entity.getSpecification().getProperty(propertyId)
- .filter(property->!property.isMixedIn())
- .filter(property->!property.isNotPersisted())
- .map(property->_PropertyChangeRecord.of(entity, property))
- .ifPresent(record -> {
- record.setPreValue(preValue);
- propertyChangeRecordsById.put(record.getPropertyId(), record);
- });
-
- }
-
private void enlistForPreAndPostValuePublishing(
final ManagedObject entity,
- final Consumer<_PropertyChangeRecord> onNewChangeRecord) {
+ final Consumer<PropertyChangeRecord> onNewChangeRecord) {
log.debug("enlist entity's property changes for publishing {}", entity);
entity.getSpecification().streamProperties(MixedIn.EXCLUDED)
.filter(property->!property.isNotPersisted())
- .map(property->_PropertyChangeRecord.of(entity, property))
+ .map(property->PropertyChangeRecord.of(entity, property))
.filter(record->!propertyChangeRecordsById.containsKey(record.getPropertyId())) // already enlisted, so ignore
.forEach(record->{
onNewChangeRecord.accept(record);
@@ -355,11 +309,11 @@ implements
* For any enlisted Object Properties collects those, that are meant for publishing,
* then clears enlisted objects.
*/
- private Set<_PropertyChangeRecord> capturePostValuesAndDrain() {
+ private Set<PropertyChangeRecord> capturePostValuesAndDrain() {
val records = propertyChangeRecordsById.values().stream()
// set post values, which have been left empty up to now
- .peek(_PropertyChangeRecord::updatePostValue)
+ .peek(PropertyChangeRecord::updatePostValue)
.filter(managedProperty->managedProperty.getPreAndPostValue().shouldPublish())
.collect(_Sets.toUnmodifiable());
@@ -410,16 +364,11 @@ implements
@Override
public void enlistUpdating(final ManagedObject entity) {
- enlistUpdating(entity, null, null);
- }
-
- @Override
- public void enlistUpdating(final ManagedObject entity, final String propertyIdIfAny, final Object preValue) {
_Xray.enlistUpdating(entity, interactionProviderProvider);
val hasAlreadyBeenEnlisted = isEnlisted(entity);
// we call this come what may;
// additional properties may now have been changed, and the changeKind for publishing might also be modified
- enlistUpdatingInternal(entity, propertyIdIfAny, preValue);
+ enlistUpdatingInternal(entity);
if(!hasAlreadyBeenEnlisted) {
// prevent an infinite loop... don't call the 'updating()' callback on this object if we have already done so
@@ -454,30 +403,4 @@ implements
private final LongAdder entityChangeEventCount = new LongAdder();
private final AtomicBoolean persitentChangesEncountered = new AtomicBoolean();
- // -- HELPER
-
- @SuppressWarnings({ "unchecked", "rawtypes" })
- private void postLifecycleEventIfRequired(
- final ManagedObject adapter,
- final Class<? extends LifecycleEventFacet> lifecycleEventFacetClass) {
-
- val lifecycleEventFacet = adapter.getSpecification().getFacet(lifecycleEventFacetClass);
- if(lifecycleEventFacet == null) {
- return;
- }
- val eventInstance = (AbstractLifecycleEvent) _InstanceUtil
- .createInstance(lifecycleEventFacet.getEventType());
- val pojo = adapter.getPojo();
- postEvent(eventInstance, pojo);
-
- }
-
- private void postEvent(final AbstractLifecycleEvent<Object> event, final Object pojo) {
- if(eventBusService!=null) {
- event.initSource(pojo);
- eventBusService.post(event);
- }
- }
-
-
}
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_ChangingEntitiesFactory.java b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_ChangingEntitiesFactory.java
similarity index 97%
rename from core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_ChangingEntitiesFactory.java
rename to persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_ChangingEntitiesFactory.java
index fde9859..224ced4 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_ChangingEntitiesFactory.java
+++ b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_ChangingEntitiesFactory.java
@@ -16,7 +16,7 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.apache.isis.core.transaction.changetracking;
+package org.apache.isis.persistence.jdo.integration.changetracking;
import java.util.HashMap;
import java.util.Map;
@@ -40,7 +40,7 @@ final class _ChangingEntitiesFactory {
public static Optional<EntityChanges> createChangingEntities(
final java.sql.Timestamp completedAt,
final String userName,
- final EntityChangeTrackerDefault entityChangeTracker) {
+ final EntityChangeTrackerJdo entityChangeTracker) {
if(entityChangeTracker.getChangeKindByEnlistedAdapter().isEmpty()) {
return Optional.empty();
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_EntityPropertyChangeFactory.java b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_EntityPropertyChangeFactory.java
similarity index 91%
rename from core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_EntityPropertyChangeFactory.java
rename to persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_EntityPropertyChangeFactory.java
index b4dd836..bb4023c 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_EntityPropertyChangeFactory.java
+++ b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_EntityPropertyChangeFactory.java
@@ -16,7 +16,7 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.apache.isis.core.transaction.changetracking;
+package org.apache.isis.persistence.jdo.integration.changetracking;
import java.util.UUID;
@@ -24,6 +24,7 @@ import org.apache.isis.applib.services.bookmark.Bookmark;
import org.apache.isis.applib.services.publishing.spi.EntityPropertyChange;
import org.apache.isis.applib.services.xactn.TransactionId;
import org.apache.isis.core.metamodel.facets.actions.action.invocation.CommandUtil;
+import org.apache.isis.core.transaction.changetracking.PropertyChangeRecord;
import lombok.val;
@@ -33,7 +34,7 @@ final class _EntityPropertyChangeFactory {
final java.sql.Timestamp timestamp,
final String user,
final TransactionId txId,
- final _PropertyChangeRecord propertyChangeRecord) {
+ final PropertyChangeRecord propertyChangeRecord) {
val spec = propertyChangeRecord.getEntity().getSpecification();
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_SimpleChangingEntities.java b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_SimpleChangingEntities.java
similarity index 98%
rename from core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_SimpleChangingEntities.java
rename to persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_SimpleChangingEntities.java
index 6f2f5b5..7cd6d33 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_SimpleChangingEntities.java
+++ b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_SimpleChangingEntities.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.isis.core.transaction.changetracking;
+package org.apache.isis.persistence.jdo.integration.changetracking;
import java.sql.Timestamp;
import java.util.UUID;
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_Xray.java b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_Xray.java
similarity index 97%
rename from core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_Xray.java
rename to persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_Xray.java
index fd9b1be..aada9ed 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_Xray.java
+++ b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_Xray.java
@@ -16,7 +16,7 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.apache.isis.core.transaction.changetracking;
+package org.apache.isis.persistence.jdo.integration.changetracking;
import java.awt.Color;
@@ -33,7 +33,7 @@ import lombok.val;
final class _Xray {
public static void publish(
- final EntityChangeTrackerDefault entityChangeTrackerDefault,
+ final EntityChangeTrackerJdo entityChangeTrackerDefault,
final Provider<InteractionProvider> interactionProviderProvider) {
if(!XrayUi.isXrayEnabled()) {
diff --git a/persistence/jpa/applib/src/main/java/org/apache/isis/persistence/jpa/applib/integration/IsisEntityListener.java b/persistence/jpa/applib/src/main/java/org/apache/isis/persistence/jpa/applib/integration/IsisEntityListener.java
index 5a782be..acb562d 100644
--- a/persistence/jpa/applib/src/main/java/org/apache/isis/persistence/jpa/applib/integration/IsisEntityListener.java
+++ b/persistence/jpa/applib/src/main/java/org/apache/isis/persistence/jpa/applib/integration/IsisEntityListener.java
@@ -29,15 +29,19 @@ import javax.persistence.PreRemove;
import javax.persistence.PreUpdate;
import org.eclipse.persistence.sessions.UnitOfWork;
+import org.eclipse.persistence.sessions.changesets.DirectToFieldChangeRecord;
import org.apache.isis.applib.services.inject.ServiceInjector;
+import org.apache.isis.commons.collections.Can;
import org.apache.isis.core.metamodel.objectmanager.ObjectManager;
import org.apache.isis.core.transaction.changetracking.EntityChangeTracker;
-import org.apache.isis.core.transaction.changetracking.EntityChangeTrackerWithPreValue;
+import org.apache.isis.core.transaction.changetracking.PreAndPostValue;
+import org.apache.isis.core.transaction.changetracking.PropertyChangePublisher;
+import org.apache.isis.core.transaction.changetracking.PropertyChangeRecord;
import org.apache.isis.persistence.jpa.applib.services.JpaSupportService;
-import lombok.extern.log4j.Log4j2;
import lombok.val;
+import lombok.extern.log4j.Log4j2;
/**
* EntityListener class for listing with the {@link javax.persistence.EntityListeners} annotation, to
@@ -59,70 +63,86 @@ public class IsisEntityListener {
// not managed by Spring (directly)
@Inject private ServiceInjector serviceInjector;
- @Inject private Provider<EntityChangeTrackerWithPreValue> entityChangeTrackerProvider;
+ @Inject private PropertyChangePublisher propertyChangePublisher;
@Inject private Provider<JpaSupportService> jpaSupportServiceProvider;
@Inject private ObjectManager objectManager;
-
- @PrePersist void onPrePersist(Object entityPojo) {
+ @PrePersist void onPrePersist(final Object entityPojo) {
log.debug("onPrePersist: {}", entityPojo);
serviceInjector.injectServicesInto(entityPojo);
val entity = objectManager.adapt(entityPojo);
- val entityChangeTracker = entityChangeTrackerProvider.get();
- entityChangeTracker.recognizePersisting(entity);
+ propertyChangePublisher.onPrePersist(entity);
}
- @PreUpdate void onPreUpdate(Object entityPojo) {
+ @PreUpdate void onPreUpdate(final Object entityPojo) {
log.debug("onPreUpdate: {}", entityPojo);
serviceInjector.injectServicesInto(entityPojo);
val entity = objectManager.adapt(entityPojo);
- val entityChangeTracker = entityChangeTrackerProvider.get();
val entityManagerResult = jpaSupportServiceProvider.get().getEntityManager(entityPojo.getClass());
entityManagerResult.getValue().ifPresent(em -> { // https://wiki.eclipse.org/EclipseLink/FAQ/JPA#How_to_access_what_changed_in_an_object_or_transaction.3F
val unwrap = em.unwrap(UnitOfWork.class);
val changes = unwrap.getCurrentChanges();
val objectChanges = changes.getObjectChangeSetForClone(entityPojo);
- val changeRecords = objectChanges.getChanges();
- changeRecords.forEach(changeRecord -> {
+
+ final Can<PropertyChangeRecord> payload = objectChanges
+ .getChanges()
+ .stream()
+ .filter(DirectToFieldChangeRecord.class::isInstance)
+ .map(DirectToFieldChangeRecord.class::cast)
+ .map(changeRecord -> {
val propertyName = changeRecord.getAttribute();
- val oldValue = changeRecord.getOldValue();
- entityChangeTracker.enlistUpdating(entity, propertyName, oldValue);
- });
+ val property = entity.getSpecification().getProperty(propertyName)
+ .filter(property->!property.isMixedIn())
+ .filter(property->!property.isNotPersisted())
+ .orElse(null);
+
+ if(property==null) {
+ return null; // ignore
+ }
+
+ return PropertyChangeRecord.of(
+ entity,
+ property,
+ PreAndPostValue
+ .pre(changeRecord.getOldValue())
+ .withPost(changeRecord.getNewValue()));
+ })
+ .collect(Can.toCan()); // a Can<T> only collects non-null elements
+
+ propertyChangePublisher.onPreUpdate(entity, payload);
+
});
}
- @PreRemove void onPreRemove(Object entityPojo) {
+ @PreRemove void onPreRemove(final Object entityPojo) {
log.debug("onAnyRemove: {}", entityPojo);
serviceInjector.injectServicesInto(entityPojo);
val entity = objectManager.adapt(entityPojo);
- val entityChangeTracker = entityChangeTrackerProvider.get();
- entityChangeTracker.enlistDeleting(entity);
+ propertyChangePublisher.onPreRemove(entity);
}
- @PostPersist void onPostPersist(Object entityPojo) {
+ @PostPersist void onPostPersist(final Object entityPojo) {
log.debug("onPostPersist: {}", entityPojo);
val entity = objectManager.adapt(entityPojo);
- val entityChangeTracker = entityChangeTrackerProvider.get();
- entityChangeTracker.enlistCreated(entity);
+ propertyChangePublisher.onPostPersist(entity);
}
- @PostUpdate void onPostUpdate(Object entityPojo) {
+ @PostUpdate void onPostUpdate(final Object entityPojo) {
log.debug("onPostUpdate: {}", entityPojo);
val entity = objectManager.adapt(entityPojo);
- val entityChangeTracker = entityChangeTrackerProvider.get();
- entityChangeTracker.recognizeUpdating(entity);
+ propertyChangePublisher.onPostUpdate(entity);
}
- @PostRemove void onPostRemove(Object entityPojo) {
+ @PostRemove void onPostRemove(final Object entityPojo) {
log.debug("onPostRemove: {}", entityPojo);
}
- @PostLoad void onPostLoad(Object entityPojo) {
+ @PostLoad void onPostLoad(final Object entityPojo) {
log.debug("onPostLoad: {}", entityPojo);
serviceInjector.injectServicesInto(entityPojo);
val entity = objectManager.adapt(entityPojo);
- val entityChangeTracker = entityChangeTrackerProvider.get();
- entityChangeTracker.recognizeLoaded(entity);
+ propertyChangePublisher.onPostRemove(entity);
}
+
}
diff --git a/persistence/jpa/integration/src/main/java/org/apache/isis/persistence/jpa/integration/IsisModuleJpaIntegration.java b/persistence/jpa/integration/src/main/java/org/apache/isis/persistence/jpa/integration/IsisModuleJpaIntegration.java
index df7537a..77f9bc5 100644
--- a/persistence/jpa/integration/src/main/java/org/apache/isis/persistence/jpa/integration/IsisModuleJpaIntegration.java
+++ b/persistence/jpa/integration/src/main/java/org/apache/isis/persistence/jpa/integration/IsisModuleJpaIntegration.java
@@ -23,6 +23,7 @@ import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.apache.isis.core.runtime.IsisModuleCoreRuntime;
+import org.apache.isis.persistence.jpa.integration.changetracking.PropertyChangePublisherJpa;
import org.apache.isis.persistence.jpa.integration.metamodel.JpaProgrammingModel;
import org.apache.isis.persistence.jpa.integration.services.JpaSupportServiceUsingSpring;
import org.apache.isis.persistence.jpa.integration.typeconverters.JavaAwtBufferedImageByteArrayConverter;
@@ -38,6 +39,7 @@ import org.apache.isis.persistence.jpa.integration.typeconverters.JavaAwtBuffere
// @Service's
JpaSupportServiceUsingSpring.class,
+ PropertyChangePublisherJpa.class,
// DataNucleusSettings.class,
// ExceptionRecognizerForSQLIntegrityConstraintViolationUniqueOrIndexException.class,
diff --git a/persistence/jpa/integration/src/main/java/org/apache/isis/persistence/jpa/integration/changetracking/PropertyChangePublisherJpa.java b/persistence/jpa/integration/src/main/java/org/apache/isis/persistence/jpa/integration/changetracking/PropertyChangePublisherJpa.java
new file mode 100644
index 0000000..201023d
--- /dev/null
+++ b/persistence/jpa/integration/src/main/java/org/apache/isis/persistence/jpa/integration/changetracking/PropertyChangePublisherJpa.java
@@ -0,0 +1,262 @@
+package org.apache.isis.persistence.jpa.integration.changetracking;
+
+import java.sql.Timestamp;
+import java.util.UUID;
+
+import javax.annotation.Priority;
+import javax.inject.Inject;
+import javax.inject.Named;
+
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Service;
+
+import org.apache.isis.applib.annotation.PriorityPrecedence;
+import org.apache.isis.applib.services.bookmark.Bookmark;
+import org.apache.isis.applib.services.eventbus.EventBusService;
+import org.apache.isis.applib.services.metrics.MetricsService;
+import org.apache.isis.applib.services.publishing.spi.EntityPropertyChange;
+import org.apache.isis.applib.services.xactn.TransactionId;
+import org.apache.isis.commons.collections.Can;
+import org.apache.isis.core.metamodel.facets.actions.action.invocation.CommandUtil;
+import org.apache.isis.core.metamodel.facets.object.callbacks.CallbackFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.PersistedCallbackFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.PersistedLifecycleEventFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.PersistingCallbackFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.PersistingLifecycleEventFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.RemovingCallbackFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.RemovingLifecycleEventFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.UpdatedCallbackFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.UpdatedLifecycleEventFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.UpdatingCallbackFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.UpdatingLifecycleEventFacet;
+import org.apache.isis.core.metamodel.spec.ManagedObject;
+import org.apache.isis.core.metamodel.spec.ManagedObjects;
+import org.apache.isis.core.metamodel.spec.feature.MixedIn;
+import org.apache.isis.core.transaction.changetracking.EntityPropertyChangePublisher;
+import org.apache.isis.core.transaction.changetracking.HasEnlistedEntityPropertyChanges;
+import org.apache.isis.core.transaction.changetracking.PersistenceCallbackHandlerAbstract;
+import org.apache.isis.core.transaction.changetracking.PreAndPostValue;
+import org.apache.isis.core.transaction.changetracking.PropertyChangePublisher;
+import org.apache.isis.core.transaction.changetracking.PropertyChangeRecord;
+import org.apache.isis.core.transaction.changetracking.events.IsisTransactionPlaceholder;
+
+import lombok.val;
+import lombok.extern.log4j.Log4j2;
+
+/**
+ * @since 2.0 {@index}
+ */
+@Service
+@Named("isis.transaction.PropertyChangePublisherJpa")
+@Priority(PriorityPrecedence.EARLY)
+@Qualifier("jpa")
+@Log4j2
+public class PropertyChangePublisherJpa
+extends PersistenceCallbackHandlerAbstract
+implements
+ MetricsService,
+ PropertyChangePublisher {
+
+ private final EntityPropertyChangePublisher entityPropertyChangePublisher;
+
+ @Inject
+ public PropertyChangePublisherJpa(
+ final EventBusService eventBusService,
+ final EntityPropertyChangePublisher entityPropertyChangePublisher) {
+ super(eventBusService);
+ this.entityPropertyChangePublisher = entityPropertyChangePublisher;
+ }
+
+ @Override
+ public void onPrePersist(final ManagedObject entity) {
+ CallbackFacet.callCallback(entity, PersistingCallbackFacet.class);
+ postLifecycleEventIfRequired(entity, PersistingLifecycleEventFacet.class);
+ }
+
+ @Override
+ public void onPreUpdate(
+ final ManagedObject entity,
+ final Can<PropertyChangeRecord> changeRecords) {
+
+ if(changeRecords.isEmpty()) {
+ return;
+ }
+
+ val payload = new HasEnlistedEntityPropertyChanges() {
+
+ @Override
+ public Can<EntityPropertyChange> getPropertyChanges(
+ final Timestamp timestamp,
+ final String user,
+ final TransactionId txId) {
+
+ return changeRecords
+ .map(changeRecord->{
+
+ log.debug("publish property change {} value '{}' -> '{}'",
+ entity.getSpecification().getLogicalTypeName(),
+ changeRecord.getPropertyId(),
+ changeRecord.getPreAndPostValue().getPre(),
+ changeRecord.getPreAndPostValue().getPost());
+
+ return toPropertyChange(changeRecord,
+ timestamp,
+ user,
+ txId);
+ });
+
+ }
+
+ };
+
+ CallbackFacet.callCallback(entity, UpdatingCallbackFacet.class);
+ postLifecycleEventIfRequired(entity, UpdatingLifecycleEventFacet.class);
+
+ entityPropertyChangePublisher.publishChangedProperties(payload);
+ }
+
+ @Override
+ public void onPreRemove(final ManagedObject entity) {
+ CallbackFacet.callCallback(entity, RemovingCallbackFacet.class);
+ postLifecycleEventIfRequired(entity, RemovingLifecycleEventFacet.class);
+
+
+ val payload = new HasEnlistedEntityPropertyChanges() {
+
+ @Override
+ public Can<EntityPropertyChange> getPropertyChanges(
+ final Timestamp timestamp,
+ final String user,
+ final TransactionId txId) {
+
+ return entity
+ .getSpecification()
+ .streamProperties(MixedIn.EXCLUDED)
+ .filter(property->!property.isMixedIn())
+ .filter(property->!property.isNotPersisted())
+ .map(property->PropertyChangeRecord.of(
+ entity,
+ property,
+ PreAndPostValue
+ .pre(property.get(entity))
+ .withPost(IsisTransactionPlaceholder.DELETED))
+ )
+ .map(changeRecord->{
+
+ log.debug("publish property change {} value '{}' -> '{}'",
+ entity.getSpecification().getLogicalTypeName(),
+ changeRecord.getPropertyId(),
+ changeRecord.getPreAndPostValue().getPre(),
+ changeRecord.getPreAndPostValue().getPost());
+
+ return toPropertyChange(changeRecord,
+ timestamp,
+ user,
+ txId);
+ })
+ .collect(Can.toCan());
+
+ }
+
+ };
+
+ entityPropertyChangePublisher.publishChangedProperties(payload);
+ }
+
+ @Override
+ public void onPostPersist(final ManagedObject entity) {
+ CallbackFacet.callCallback(entity, PersistedCallbackFacet.class);
+ postLifecycleEventIfRequired(entity, PersistedLifecycleEventFacet.class);
+
+ val payload = new HasEnlistedEntityPropertyChanges() {
+
+ @Override
+ public Can<EntityPropertyChange> getPropertyChanges(
+ final Timestamp timestamp,
+ final String user,
+ final TransactionId txId) {
+
+ return entity
+ .getSpecification()
+ .streamProperties(MixedIn.EXCLUDED)
+ .filter(property->!property.isMixedIn())
+ .filter(property->!property.isNotPersisted())
+ .map(property->PropertyChangeRecord.of(
+ entity,
+ property,
+ PreAndPostValue
+ .pre(IsisTransactionPlaceholder.NEW)
+ .withPost(property.get(entity)))
+ )
+ .map(changeRecord->{
+
+ log.debug("publish property change {} value '{}' -> '{}'",
+ entity.getSpecification().getLogicalTypeName(),
+ changeRecord.getPropertyId(),
+ changeRecord.getPreAndPostValue().getPre(),
+ changeRecord.getPreAndPostValue().getPost());
+
+ return toPropertyChange(changeRecord,
+ timestamp,
+ user,
+ txId);
+ })
+ .collect(Can.toCan());
+
+ }
+
+ };
+
+ entityPropertyChangePublisher.publishChangedProperties(payload);
+ }
+
+ @Override
+ public void onPostUpdate(final ManagedObject entity) {
+ CallbackFacet.callCallback(entity, UpdatedCallbackFacet.class);
+ postLifecycleEventIfRequired(entity, UpdatedLifecycleEventFacet.class);
+ }
+
+ @Override
+ public void onPostRemove(final ManagedObject entity) {
+ // not used
+ }
+
+ @Override
+ public int numberEntitiesLoaded() {
+ return -1; // n/a
+ }
+
+ @Override
+ public int numberEntitiesDirtied() {
+ return -1; // n/a
+ }
+
+ // -- HELPER
+
+ private EntityPropertyChange toPropertyChange(
+ final PropertyChangeRecord record,
+ final Timestamp timestamp,
+ final String user,
+ final TransactionId txId) {
+
+ val entity = record.getEntity();
+ val spec = entity.getSpecification();
+ val property = record.getProperty();
+
+ final Bookmark target = ManagedObjects.bookmarkElseFail(entity);
+ final String propertyId = property.getId();
+ final String memberId = property.getFeatureIdentifier().getFullIdentityString();
+ final String preValueStr = record.getPreAndPostValue().getPreString();
+ final String postValueStr = record.getPreAndPostValue().getPostString();
+ final String targetClass = CommandUtil.targetClassNameFor(spec);
+
+ final UUID transactionId = txId.getInteractionId();
+ final int sequence = txId.getSequence();
+
+
+ return EntityPropertyChange.of(
+ transactionId, sequence, targetClass, target,
+ memberId, propertyId, preValueStr, postValueStr, user, timestamp);
+ }
+
+}
diff --git a/regressiontests/incubating/src/test/java/org/apache/isis/testdomain/publishing/jpa/JpaEntityPublishingTest.java b/regressiontests/incubating/src/test/java/org/apache/isis/testdomain/publishing/jpa/JpaEntityPublishingTest.java
index 25234c8..2c2cca1 100644
--- a/regressiontests/incubating/src/test/java/org/apache/isis/testdomain/publishing/jpa/JpaEntityPublishingTest.java
+++ b/regressiontests/incubating/src/test/java/org/apache/isis/testdomain/publishing/jpa/JpaEntityPublishingTest.java
@@ -22,6 +22,7 @@ import java.util.List;
import javax.inject.Inject;
+import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.TestFactory;
@@ -55,6 +56,7 @@ implements HasPersistenceStandardJpa {
@Inject private PublishingTestFactoryJpa testFactory;
+ @Disabled("'Entity Changes Tracking' currently not supported for JPA")
@TestFactory @DisplayName("Execution Scenario")
List<DynamicTest> generateTests() {
return testFactory.generateTestsIncludeProgrammatic(this::given, this::verify);
diff --git a/regressiontests/stable/src/main/java/org/apache/isis/testdomain/publishing/PublishingTestFactoryAbstract.java b/regressiontests/stable/src/main/java/org/apache/isis/testdomain/publishing/PublishingTestFactoryAbstract.java
index b8e9e00..b70f297 100644
--- a/regressiontests/stable/src/main/java/org/apache/isis/testdomain/publishing/PublishingTestFactoryAbstract.java
+++ b/regressiontests/stable/src/main/java/org/apache/isis/testdomain/publishing/PublishingTestFactoryAbstract.java
@@ -218,12 +218,12 @@ public abstract class PublishingTestFactoryAbstract {
PublishingTestContext.of("Wrapper Sync w/ Rules (expected to fail w/ DisabledException)",
given, verifier, VerificationStage.FAILURE_CASE),
VerificationStage.POST_INTERACTION,
- this::wrapperSyncExecutionWithFailure),
- publishingTest(
- PublishingTestContext.of("Wrapper Async w/ Rules (expected to fail w/ DisabledException)",
- given, verifier, VerificationStage.FAILURE_CASE),
- VerificationStage.POST_INTERACTION,
- this::wrapperAsyncExecutionWithFailure)
+ this::wrapperSyncExecutionWithFailure)
+// publishingTest(
+// PublishingTestContext.of("Wrapper Async w/ Rules (expected to fail w/ DisabledException)",
+// given, verifier, VerificationStage.FAILURE_CASE),
+// VerificationStage.POST_INTERACTION,
+// this::wrapperAsyncExecutionWithFailure)
);
if(includeProgrammatic) {