protected void adjustState(Entity committedEntity) { if (committedEntity instanceof AbstractNotPersistentEntity) { BaseEntityInternalAccess.setNew((AbstractNotPersistentEntity) committedEntity, false); } else if (committedEntity instanceof BaseGenericIdEntity && metadataTools.isTransient(committedEntity.getClass())) { BaseEntityInternalAccess.setNew((BaseGenericIdEntity) committedEntity, false); } }
/** * Makes a newly constructed object detached. The detached object can be passed to {@code DataManager.commit()} or * to {@code EntityManager.merge()} to save its state to the database. * <p>If an object with such ID does not exist in the database, a new object will be inserted. * <p>If the entity is {@code Versioned}, the version attribute should be equal to the latest version existing in * the database, or null for a new object. * * @param entity entity in the New state * @throws IllegalStateException if the entity is Managed * @see #isDetached(Object) * @see #makePatch(BaseGenericIdEntity) */ public void makeDetached(BaseGenericIdEntity entity) { checkNotNullArgument(entity, "entity is null"); if (BaseEntityInternalAccess.isManaged(entity)) throw new IllegalStateException("entity is managed"); BaseEntityInternalAccess.setNew(entity, false); BaseEntityInternalAccess.setDetached(entity, true); }
/** * Makes a newly constructed object a patch object. The patch object is {@code !isNew() && !isDetached() && !isManaged()}. * The patch object can be passed to {@code DataManager.commit()} or * to {@code EntityManager.merge()} to save its state to the database. Only <b>non-null values</b> of attributes are * updated. * <p>If an object with such ID does not exist in the database, a new object will be inserted. * <p>If the entity is {@code Versioned}, the version attribute should be null or equal to the latest version existing in * the database. * * @param entity entity in the New or Detached state * @throws IllegalStateException if the entity is Managed * @see #isDetached(Object) * @see #makeDetached(BaseGenericIdEntity) */ public void makePatch(BaseGenericIdEntity entity) { checkNotNullArgument(entity, "entity is null"); if (BaseEntityInternalAccess.isManaged(entity)) throw new IllegalStateException("entity is managed"); BaseEntityInternalAccess.setNew(entity, false); BaseEntityInternalAccess.setDetached(entity, false); } }
@SuppressWarnings("unchecked") @Override public <T extends Entity<K>, K> T getReference(Class<T> clazz, K id) { Class<T> effectiveClass = metadata.getExtendedEntities().getEffectiveClass(clazz); T reference = delegate.getReference(effectiveClass, getRealId(id)); BaseEntityInternalAccess.setNew((BaseGenericIdEntity) reference, false); return reference; }
protected void makeDetached(Object instance) { if (instance instanceof BaseGenericIdEntity) { BaseEntityInternalAccess.setNew((BaseGenericIdEntity) instance, false); BaseEntityInternalAccess.setManaged((BaseGenericIdEntity) instance, false); BaseEntityInternalAccess.setDetached((BaseGenericIdEntity) instance, true); } if (instance instanceof FetchGroupTracker) { ((FetchGroupTracker) instance)._persistence_setSession(null); } if (instance instanceof ChangeTracker) { ((ChangeTracker) instance)._persistence_setPropertyChangeListener(null); } }
@Override public void afterCompletion(int status) { try { Collection<Entity> instances = container.getAllInstances(); if (log.isTraceEnabled()) log.trace("ContainerResourceSynchronization.afterCompletion: instances = " + instances); for (Object instance : instances) { if (instance instanceof BaseGenericIdEntity) { if (status == TransactionSynchronization.STATUS_COMMITTED) { if (BaseEntityInternalAccess.isNew((BaseGenericIdEntity) instance)) { // new instances become not new and detached only if the transaction was committed BaseEntityInternalAccess.setNew((BaseGenericIdEntity) instance, false); } } else { // commit failed or the transaction was rolled back makeDetached(instance); for (Entity entity : container.getNewDetachedInstances()) { BaseEntityInternalAccess.setNew((BaseGenericIdEntity) entity, true); BaseEntityInternalAccess.setDetached((BaseGenericIdEntity) entity, false); } } } } for (AfterCompleteTransactionListener listener : afterCompleteTxListeners) { listener.afterComplete(status == TransactionSynchronization.STATUS_COMMITTED, instances); } } finally { super.afterCompletion(status); } }
@Override public void postBuild(DescriptorEvent event) { if (event.getObject() instanceof BaseGenericIdEntity) { BaseEntityInternalAccess.setNew((BaseGenericIdEntity) event.getObject(), false); } if (event.getObject() instanceof FetchGroupTracker) { FetchGroupTracker entity = (FetchGroupTracker) event.getObject(); FetchGroup fetchGroup = entity._persistence_getFetchGroup(); if (fetchGroup != null && !(fetchGroup instanceof CubaEntityFetchGroup)) entity._persistence_setFetchGroup(new CubaEntityFetchGroup(fetchGroup)); } }
protected void mergeSystemState(Entity srcEntity, Entity dstEntity) { if (dstEntity instanceof BaseGenericIdEntity) { BaseEntityInternalAccess.copySystemState((BaseGenericIdEntity) srcEntity, (BaseGenericIdEntity) dstEntity); if (srcEntity instanceof FetchGroupTracker && dstEntity instanceof FetchGroupTracker) { FetchGroup srcFetchGroup = ((FetchGroupTracker) srcEntity)._persistence_getFetchGroup(); FetchGroup dstFetchGroup = ((FetchGroupTracker) dstEntity)._persistence_getFetchGroup(); if (srcFetchGroup == null || dstFetchGroup == null) { ((FetchGroupTracker) dstEntity)._persistence_setFetchGroup(null); } else { ((FetchGroupTracker) dstEntity)._persistence_setFetchGroup(FetchGroupUtils.mergeFetchGroups(srcFetchGroup, dstFetchGroup)); } } } else if (dstEntity instanceof AbstractNotPersistentEntity) { BaseEntityInternalAccess.setNew((AbstractNotPersistentEntity) dstEntity, BaseEntityInternalAccess.isNew((AbstractNotPersistentEntity) srcEntity)); } }
@SuppressWarnings("unchecked") protected void copySystemState(Entity srcEntity, Entity dstEntity) { if (dstEntity instanceof BaseGenericIdEntity) { ((BaseGenericIdEntity) dstEntity).setId(srcEntity.getId()); BaseEntityInternalAccess.copySystemState((BaseGenericIdEntity) srcEntity, (BaseGenericIdEntity) dstEntity); if (srcEntity instanceof FetchGroupTracker && dstEntity instanceof FetchGroupTracker) { FetchGroup srcFetchGroup = ((FetchGroupTracker) srcEntity)._persistence_getFetchGroup(); ((FetchGroupTracker) dstEntity)._persistence_setFetchGroup(srcFetchGroup); } } else if (dstEntity instanceof AbstractNotPersistentEntity) { ((AbstractNotPersistentEntity) dstEntity).setId((UUID) srcEntity.getId()); BaseEntityInternalAccess.setNew((AbstractNotPersistentEntity) dstEntity, BaseEntityInternalAccess.isNew((AbstractNotPersistentEntity) srcEntity)); } if (dstEntity instanceof Versioned) { ((Versioned) dstEntity).setVersion(((Versioned) srcEntity).getVersion()); } }
@Override public void postClone(DescriptorEvent event) { // in shared cache mode, postBuild event is missed, so we repeat it here if (event.getObject() instanceof BaseGenericIdEntity) { BaseEntityInternalAccess.setNew((BaseGenericIdEntity) event.getObject(), false); } if (event.getObject() instanceof FetchGroupTracker) { FetchGroupTracker entity = (FetchGroupTracker) event.getObject(); FetchGroup fetchGroup = entity._persistence_getFetchGroup(); if (fetchGroup != null && !(fetchGroup instanceof CubaEntityFetchGroup)) entity._persistence_setFetchGroup(new CubaEntityFetchGroup(fetchGroup)); } if (event.getObject() instanceof Entity) support.registerInstance((Entity) event.getObject(), event.getSession()); }
BaseEntityInternalAccess.setNew(destGenericEntity, BaseEntityInternalAccess.isNew(sourceGenericEntity)); destGenericEntity.setDynamicAttributes(sourceGenericEntity.getDynamicAttributes());