/** * {@inheritDoc} */ @Override public Map<Class<? extends IEntity>, Map<Serializable, IEntity>> getUnitOfWorkEntities() { if (!isUnitOfWorkActive()) { throw new BackendException("Cannot query a unit of work that has not begun."); } return unitOfWork.getRegisteredEntities(); }
/** * {@inheritDoc} */ @Override public boolean isUpdatedInUnitOfWork(IEntity entity) { if (!isUnitOfWorkActive()) { throw new BackendException("Cannot access unit of work."); } return unitOfWork.isUpdated(entity); }
/** * {@inheritDoc} */ @Override public void registerForUpdate(IEntity entity) { if (entity == null) { throw new IllegalArgumentException("Passed entity cannot be null"); } if (isUnitOfWorkActive()) { unitOfWork.registerForUpdate(entity); } else { sessionUnitOfWork.registerForUpdate(entity); } }
/** * {@inheritDoc} */ @Override public void setDirtyTrackingEnabled(boolean enabled) { // Both session AND UOW dirty tracker should be disabled at the same time. See bug #jspresso-ce-21. sessionUnitOfWork.setDirtyTrackingEnabled(enabled); if (isUnitOfWorkActive()) { unitOfWork.setDirtyTrackingEnabled(enabled); } }
/** * {@inheritDoc}. */ @Override public void removeDirtInterceptor(PropertyChangeListener interceptor) { if (isUnitOfWorkActive()) { unitOfWork.removeDirtInterceptor(interceptor); } else { sessionUnitOfWork.removeDirtInterceptor(interceptor); } }
/** * {@inheritDoc} */ @Override public void registerForDeletion(IEntity entity) { if (entity == null) { throw new IllegalArgumentException("Passed entity cannot be null"); } if (isUnitOfWorkActive()) { unitOfWork.registerForDeletion(entity); } else { sessionUnitOfWork.registerForDeletion(entity); } }
/** * {@inheritDoc} */ @Override public IEntity getUnitOfWorkEntity(Class<? extends IEntity> entityContract, Serializable entityId) { if (!isUnitOfWorkActive()) { throw new BackendException("Cannot query a unit of work that has not begun."); } return unitOfWork.getRegisteredEntity(entityContract, entityId); }
/** * {@inheritDoc} */ @Override public boolean isEntityRegisteredForUpdate(IEntity entity) { if (isUnitOfWorkActive()) { return unitOfWork.isEntityRegisteredForUpdate(entity); } else { return sessionUnitOfWork.isEntityRegisteredForUpdate(entity); } }
/** * {@inheritDoc} */ @Override public boolean isEntityRegisteredForDeletion(IEntity entity) { if (isUnitOfWorkActive()) { return unitOfWork.isEntityRegisteredForDeletion(entity); } else { return sessionUnitOfWork.isEntityRegisteredForDeletion(entity); } }
/** * {@inheritDoc}. */ @Override public void addDirtInterceptor(PropertyChangeListener interceptor) { if (isUnitOfWorkActive()) { unitOfWork.addDirtInterceptor(interceptor); } else { sessionUnitOfWork.addDirtInterceptor(interceptor); } }
/** * {@inheritDoc} */ @Override public void registerEntity(IEntity entity) { Map<String, Object> initialDirtyProperties = null; if (!entity.isPersistent()) { initialDirtyProperties = new HashMap<>(); for (Map.Entry<String, Object> property : entity.straightGetProperties().entrySet()) { String propertyName = property.getKey(); Object propertyValue = property.getValue(); if (propertyValue != null && !(propertyValue instanceof Collection<?> && ((Collection<?>) property.getValue()) .isEmpty())) { initialDirtyProperties.put(propertyName, null); } } } if (isUnitOfWorkActive()) { unitOfWork.register(entity, initialDirtyProperties); } else { sessionUnitOfWork.register(entity, initialDirtyProperties); } }
/** * Gets unit of work or registered entity. * * @param entityType * the entity type * @param id * the id * @return the unit of work or registered entity */ @Override public IEntity getUnitOfWorkOrRegisteredEntity(Class<? extends IEntity> entityType, Serializable id) { IEntity entity; if (isUnitOfWorkActive()) { entity = getUnitOfWorkEntity(entityType, id); } else { entity = getRegisteredEntity(entityType, id); } return entity; }
private <E extends IEntity> void checkBadMergeUsage(E entity) { if (isUnitOfWorkActive()) { if (isInitialized(entity) && entity.isPersistent() && isDirty(entity)) { String message = MessageFormatter.arrayFormat( "*BAD MERGE USAGE* An attempt is made to merge a UOW dirty entity ({})[{}] to the application session.\n" + "This will break transaction isolation since, if the transaction is rolled back," + " the UOW dirty state will be kept.\n" + "Dirty UOW entities will be automatically merged whenever the transaction is committed.", new Object[]{entity, getComponentContract(entity).getSimpleName()}).getMessage(); LOG.error(message); if (isThrowExceptionOnBadUsage()) { throw new BackendException("A bad usage has been detected on the backend controller." + "This is certainly an application coding problem:\n" + message); } } } }
/** * {@inheritDoc} */ @Override public final void beginUnitOfWork() { if (isUnitOfWorkSuspended()) { return; } if (isUnitOfWorkActive()) { throw new BackendException("Cannot begin a new unit of work. Another one is already active."); } doBeginUnitOfWork(); }
/** * {@inheritDoc} */ @Override public void joinTransaction(boolean nested) { TransactionSynchronizationManager.registerSynchronization(this); if (!isUnitOfWorkActive()) { beginUnitOfWork(); } else if (nested) { beginNestedUnitOfWork(); } }
if (isUnitOfWorkActive()) { Map<String, Object> hasActuallyBeenFlushed = getDirtyProperties(flushedEntity, false); if (hasActuallyBeenFlushed == null) {
/** * {@inheritDoc} */ @Override public <E extends IEntity> List<E> cloneInUnitOfWork(List<E> entities) { if (!isUnitOfWorkActive()) { throw new BackendException("Cannot use a unit of work that has not begun."); } List<E> uowEntities = new ArrayList<>(); IEntityRegistry alreadyCloned = getUowEntityRegistry(); Set<IEntity> eventsToRelease = new LinkedHashSet<>(); boolean wasDirtyTrackingEnabled = isDirtyTrackingEnabled(); try { setDirtyTrackingEnabled(false); for (E entity : entities) { uowEntities.add(cloneInUnitOfWork(entity, alreadyCloned, eventsToRelease)); } } finally { for (IEntity entity : eventsToRelease) { try { entity.releaseEvents(); } catch (Throwable t) { LOG.error("An unexpected exception occurred when releasing events after a merge", t); } } setDirtyTrackingEnabled(wasDirtyTrackingEnabled); } return uowEntities; }
boolean suspendUnitOfWork = isUnitOfWorkActive(); try { if (suspendUnitOfWork) {
/** * {@inheritDoc} */ @Override public final void rollbackUnitOfWork() { if (isUnitOfWorkSuspended()) { return; } if (!isUnitOfWorkActive()) { throw new BackendException("Cannot rollback a unit of work that has not begun."); } if (unitOfWork.hasNested()) { unitOfWork.rollback(); } else { doRollbackUnitOfWork(); } }
/** * {@inheritDoc} */ @Override public final void commitUnitOfWork() { if (isUnitOfWorkSuspended()) { return; } if (!isUnitOfWorkActive()) { throw new BackendException("Cannot commit a unit of work that has not begun."); } if (unitOfWork.hasNested()) { unitOfWork.commit(); } else { doCommitUnitOfWork(); } }