@Override public void preUpdateWithChanges(DescriptorEvent event) { ((WorkspaceImpl) event.getObject()).syncName(); } }
/** * PUBLIC: * The source object represents the object the event is being raised on, * some events also require a second object, for example the original object in a postClone. * * @see EventObject#getSource() */ public Object getOriginalObject() { // Compute the original for unit of work writes. if ((originalObject == null) && getSession().isUnitOfWork() && (getQuery() != null) && (getQuery().isObjectLevelModifyQuery())) { setOriginalObject(((UnitOfWorkImpl)getSession()).getOriginalVersionOfObject(getSource())); } return originalObject; }
protected void postBuildAttributesIntoWorkingCopyCloneEvent(Object clone, AbstractRecord databaseRow, ObjectBuildingQuery query, UnitOfWorkImpl unitOfWork, boolean forRefresh) { // Need to run post build or refresh selector, currently check with the query for this, // I'm not sure which should be called it case of refresh building a new object, currently refresh is used... DescriptorEvent event = new DescriptorEvent(clone); event.setQuery(query); event.setSession(unitOfWork); event.setDescriptor(this.descriptor); event.setRecord(databaseRow); if (forRefresh) { event.setEventCode(DescriptorEventManager.PostRefreshEvent); } else { event.setEventCode(DescriptorEventManager.PostBuildEvent); //fire a postBuildEvent then the postCloneEvent unitOfWork.deferEvent(event); event = new DescriptorEvent(clone); event.setQuery(query); event.setSession(unitOfWork); event.setDescriptor(this.descriptor); event.setRecord(databaseRow); //bug 259404: ensure postClone is called for objects built directly into the UnitOfWork //in this case, the original is the clone event.setOriginalObject(clone); event.setEventCode(DescriptorEventManager.PostCloneEvent); } unitOfWork.deferEvent(event); }
/** * INTERNAL: */ public String toString() { String eventName = "UnkownEvent"; if ((getEventCode() >= 0) && (getEventCode() < DescriptorEventManager.NumberOfEvents)) { eventName = eventNames[getEventCode()]; } return eventName + "(" + getSource().getClass() + ")"; }
DatabaseMapping mapping = this.query.getDescriptor().getObjectBuilder().getMappingForAttributeName(attributeName); if (mapping == null) { throw DescriptorException.mappingForAttributeIsMissing(attributeName, getDescriptor()); Object clone = this.getObject(); Object cloneValue = value; Object original = null; original = this.getOriginalObject(); ObjectChangeSet eventChangeSet = this.getChangeSet(); Object valueForChangeSet = value; ClassDescriptor descriptor = getSession().getDescriptor(value.getClass()); valueForChangeSet = descriptor.getObjectBuilder().createObjectChangeSet(value, (UnitOfWorkChangeSet)eventChangeSet.getUOWChangeSet(), getSession()); originalValue = ((UnitOfWorkImpl)getSession()).getOriginalVersionOfObject(value); Object collection = mapping.getRealCollectionAttributeValueFromObject(clone, getSession()); mapping.getContainerPolicy().removeFrom(mapKey, cloneValue, collection, getSession()); Object collection = mapping.getRealCollectionAttributeValueFromObject(original, getSession()); mapping.getContainerPolicy().removeFrom(mapKey, originalValue, collection, getSession()); if (getRecord() != null) { AbstractRecord tempRow = getDescriptor().getObjectBuilder().createRecord(getSession()); mapping.writeFromObjectIntoRow(clone, tempRow, getSession());
/** * INTERNAL: * Merge the contents of one object into another, this merge algorithm is dependent on the merge manager. * This merge also prevents the extra step of calculating the changes when it is not required. * If 'cascadeOnly' is true, only foreign reference mappings are merged. * If 'isTargetCloneOfOriginal' then the target was create through a shallow clone of the source, so merge basics is not required. */ public void mergeIntoObject(Object target, boolean isUnInitialized, Object source, MergeManager mergeManager, boolean cascadeOnly, boolean isTargetCloneOfOriginal) { // cascadeOnly is introduced to optimize merge // for GF#1139 Cascade merge operations to relationship mappings even if already registered // PERF: Avoid synchronized enumerator as is concurrency bottleneck. List mappings = this.descriptor.getMappings(); for (int index = 0; index < mappings.size(); index++) { DatabaseMapping mapping = (DatabaseMapping)mappings.get(index); if ((!cascadeOnly && !isTargetCloneOfOriginal) || (cascadeOnly && mapping.isForeignReferenceMapping()) || (isTargetCloneOfOriginal && mapping.isCloningRequired())) { mapping.mergeIntoObject(target, isUnInitialized, source, mergeManager); } } // PERF: Avoid events if no listeners. if (this.descriptor.getEventManager().hasAnyEventListeners()) { org.eclipse.persistence.descriptors.DescriptorEvent event = new org.eclipse.persistence.descriptors.DescriptorEvent(target); event.setSession(mergeManager.getSession()); event.setOriginalObject(source); event.setEventCode(DescriptorEventManager.PostMergeEvent); this.descriptor.getEventManager().executeEvent(event); } }
/** * PUBLIC: * Re-populate the database row with the values from the source object based upon the * attribute's mapping. Provided as a helper method for modifying the row during event * handling. */ public void applyAttributeValuesIntoRow(String attributeName) { ClassDescriptor descriptor = getSession().getDescriptor(getSource()); DatabaseMapping mapping = descriptor.getObjectBuilder().getMappingForAttributeName(attributeName); if (mapping == null) { throw ValidationException.missingMappingForAttribute(descriptor, attributeName, this.toString()); } if (getRecord() != null) { mapping.writeFromObjectIntoRow(getSource(), (AbstractRecord)getRecord(), getSession(), WriteType.UNDEFINED); } }
event.getSession().startOperationProfile(SessionProfiler.DescriptorEvent); event.setDescriptor(getDescriptor()); notifyListeners(event); notifyEJB30Listeners(event); if (event.getSource() instanceof DescriptorEventListener) { notifyListener((DescriptorEventListener)event.getSource(), event); return; Method eventMethod = (Method)getEventMethods().elementAt(event.getEventCode()); if (eventMethod == null) { return; if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){ try { AccessController.doPrivileged(new PrivilegedMethodInvoker(eventMethod, event.getSource(), runtimeParameters)); } catch (PrivilegedActionException exception) { Exception throwableException = exception.getException(); PrivilegedAccessHelper.invokeMethod(eventMethod, event.getSource(), runtimeParameters); event.getSession().endOperationProfile(SessionProfiler.DescriptorEvent);
@Override public void preUpdate (DescriptorEvent event) { Object source = event.getSource(); UnitOfWorkImpl unitOfWork = (UnitOfWorkImpl )event.getSession(); // preUpdate is also generated for deleted objects that were modified in this UOW. // Do not perform preUpdate validation for such objects as preRemove would have already been called. if(!unitOfWork.isObjectDeleted(source)) { validateOnCallbackEvent(event, "preUpdate", groupPreUpdate); } }
protected void postBuildAttributesIntoObjectEvent(Object domainObject, AbstractRecord databaseRow, ObjectBuildingQuery query, boolean forRefresh) { DescriptorEventManager descriptorEventManager = this.descriptor.getDescriptorEventManager(); if(descriptorEventManager.hasAnyEventListeners()) { // Need to run post build or refresh selector, currently check with the query for this, // I'm not sure which should be called it case of refresh building a new object, currently refresh is used... org.eclipse.persistence.descriptors.DescriptorEvent event = new DescriptorEvent(domainObject); event.setQuery(query); event.setSession(query.getSession()); event.setRecord(databaseRow); if (forRefresh) { //this method can be called from different places within TopLink. We may be //executing refresh query but building the object not refreshing so we must //throw the appropriate event. //bug 3325315 event.setEventCode(DescriptorEventManager.PostRefreshEvent); } else { event.setEventCode(DescriptorEventManager.PostBuildEvent); } descriptorEventManager.executeEvent(event); } }
@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()); }
/** * PUBLIC: * Synanym for source. */ public Object getObject() { return getSource(); }
/** * INTERNAL: * Register the working copy of a new object and its original. * The user must edit the working copy and the original is used to merge into the parent. * This mapping is kept both ways because lookup is required in both directions. */ protected void registerNewObjectClone(Object clone, Object original, ClassDescriptor descriptor) { // Check if the new objects should be cached. registerNewObjectInIdentityMap(clone, original, descriptor); getNewObjectsCloneToOriginal().put(clone, original); if (original != null) { getNewObjectsOriginalToClone().put(original, clone); } // run prePersist callbacks if any if (descriptor.getEventManager().hasAnyEventListeners()) { DescriptorEvent event = new DescriptorEvent(clone); event.setEventCode(DescriptorEventManager.PrePersistEvent); event.setSession(this); descriptor.getEventManager().executeEvent(event); } }
public class ChangeAbstractEntityListener extends DescriptorEventAdapter { @Override public void preUpdate(DescriptorEvent event) { AbstractEntity originalEntity = (AbstractEntity) event.getOriginalObject(); AbstractEntity entity = (AbstractEntity) event.getObject(); if (!EqualsBuilder.reflectionEquals(originalEntity, entity, true)) { if (!(entity instanceof LogEntry)) { LogEntry logEntry = new LogEntry(); logEntry.setPerson(getSessionController().getCurrentUser()); logEntry.setAbstractEntity(entity); entity.getLogEntries().add(logEntry); } } } //jndi lookup to get the user object }
@Override public void postMerge(DescriptorEvent event) { if ((event.getChangeSet() != null) && event.getChangeSet().hasChanges()) { Object id = event.getChangeSet().getId(); CacheKey cacheKey = event.getChangeSet().getActiveCacheKey(); if (cacheKey == null) { cacheKey = event.getSession().getParent().getIdentityMapAccessorInstance().getIdentityMapManager().getCacheKeyForObject(id, descriptor.getJavaClass(), descriptor, false); } cacheKey.setTransactionId(event.getSession().getProperty(ORA_TRANSACTION_ID)); if (event.getChangeSet().isNew()) { AbstractRecord row = descriptor.getObjectBuilder().buildRowFromPrimaryKeyValues(id, event.getSession()); Object rowid = event.getSession().executeQuery(rowIdQuery, row); CacheId indexValue = new CacheId(new Object[]{rowid}); event.getSession().getParent().getIdentityMapAccessorInstance().getIdentityMapManager().putCacheKeyByIndex(index, indexValue, cacheKey, descriptor); } } } @Override
@Override public void postUpdate(DescriptorEvent event) { Object txId = event.getSession().getProperty(ORA_TRANSACTION_ID); if (txId == null) { txId = event.getSession().executeQuery(transactionIdQuery); event.getSession().setProperty(ORA_TRANSACTION_ID, txId); } } });
private static boolean isSoftDeleted(final DescriptorEvent event) { final ObjectChangeSet changeSet = ((UpdateObjectQuery) event.getQuery()).getObjectChangeSet(); final List<DirectToFieldChangeRecord> changes = changeSet.getChanges().stream() .filter(record -> record instanceof DirectToFieldChangeRecord) .map(record -> (DirectToFieldChangeRecord) record).collect(Collectors.toList()); return changes.stream().filter(record -> DELETED_PROPERTY.equals(record.getAttribute()) && Boolean.parseBoolean(record.getNewValue().toString())).count() > 0; }
public static DescriptorException invalidDescriptorEventCode(DescriptorEvent event, ClassDescriptor descriptor) { Object[] args = { Integer.valueOf(event.getEventCode()) }; DescriptorException descriptorException = new DescriptorException(ExceptionMessageGenerator.buildMessage(DescriptorException.class, INVALID_DESCRIPTOR_EVENT_CODE, args), descriptor); descriptorException.setErrorCode(INVALID_DESCRIPTOR_EVENT_CODE); return descriptorException; }
/** * INTERNAL: * Execute a descriptor event for the specified event code. */ protected void executeEvent(int eventCode, ObjectLevelModifyQuery query) { ClassDescriptor referenceDescriptor = getReferenceDescriptor(query.getObject().getClass(), query.getSession()); // PERF: Avoid events if no listeners. if (referenceDescriptor.getEventManager().hasAnyEventListeners()) { referenceDescriptor.getEventManager().executeEvent(new DescriptorEvent(eventCode, query)); } }