private void postInsert() {
	final EventListenerGroup<PostInsertEventListener> listenerGroup = listenerGroup( EventType.POST_INSERT );
	if ( listenerGroup.isEmpty() ) {
		return;
	}
	final PostInsertEvent event = new PostInsertEvent(
			getInstance(),
			getId(),
			getState(),
			getPersister(),
			eventSource()
	);
	for ( PostInsertEventListener listener : listenerGroup.listeners() ) {
		listener.onPostInsert( event );
	}
}
 

private void postInsert() {
	if ( isDelayed ) {
		getSession().getPersistenceContext().replaceDelayedEntityIdentityInsertKeys( delayedEntityKey, generatedId );
	}

	final EventListenerGroup<PostInsertEventListener> listenerGroup = listenerGroup( EventType.POST_INSERT );
	if ( listenerGroup.isEmpty() ) {
		return;
	}
	final PostInsertEvent event = new PostInsertEvent(
			getInstance(),
			generatedId,
			getState(),
			getPersister(),
			eventSource()
	);
	for ( PostInsertEventListener listener : listenerGroup.listeners() ) {
		listener.onPostInsert( event );
	}
}
 

@Override
public void onPostInsert(PostInsertEvent event) {
    Repository repository = null;
    Object entity = event.getEntity();

    if (entity instanceof RepositoryLocale) {
        RepositoryLocale repositoryLocale = (RepositoryLocale) entity;
        repository = repositoryLocale.getRepository();
        logger.debug("Repository statistics is outdated because locale is added");
    } else if (entity instanceof TMTextUnitVariant) {
        TMTextUnitVariant tmTextUnitVariant = (TMTextUnitVariant) entity;
        TMTextUnit tmTextUnit = tmTextUnitVariant.getTmTextUnit();
        repository = tmTextUnit.getAsset().getRepository();
        logger.debug("Repository statistics is outdated because string/translation is added");
    }

    setRepositoryStatistisOutOfDate(repository);
}
 

private void postCommitInsert(boolean success) {
	final EventListenerGroup<PostInsertEventListener> listenerGroup = listenerGroup( EventType.POST_COMMIT_INSERT );
	if ( listenerGroup.isEmpty() ) {
		return;
	}
	final PostInsertEvent event = new PostInsertEvent(
			getInstance(),
			getId(),
			getState(),
			getPersister(),
			eventSource()
	);
	for ( PostInsertEventListener listener : listenerGroup.listeners() ) {
		if ( PostCommitInsertEventListener.class.isInstance( listener ) ) {
			if ( success ) {
				listener.onPostInsert( event );
			}
			else {
				((PostCommitInsertEventListener) listener).onPostInsertCommitFailed( event );
			}
		}
		else {
			//default to the legacy implementation that always fires the event
			listener.onPostInsert( event );
		}
	}
}
 

private void postCommitInsert(boolean success) {
	final EventListenerGroup<PostInsertEventListener> listenerGroup = listenerGroup( EventType.POST_COMMIT_INSERT );
	if ( listenerGroup.isEmpty() ) {
		return;
	}
	final PostInsertEvent event = new PostInsertEvent(
			getInstance(),
			generatedId,
			getState(),
			getPersister(),
			eventSource()
	);
	for ( PostInsertEventListener listener : listenerGroup.listeners() ) {
		if ( PostCommitInsertEventListener.class.isInstance( listener ) ) {
			if ( success ) {
				listener.onPostInsert( event );
			}
			else {
				((PostCommitInsertEventListener) listener).onPostInsertCommitFailed( event );
			}
		}
		else {
			//default to the legacy implementation that always fires the event
			listener.onPostInsert( event );
		}
	}
}
 

public void onPostInsert(PostInsertEvent hibernateEvent) {
    Object entity = hibernateEvent.getEntity();
    org.grails.datastore.mapping.engine.event.PostInsertEvent grailsEvent = new org.grails.datastore.mapping.engine.event.PostInsertEvent(
            this.datastore, entity);
    activateDirtyChecking(entity);
    publishEvent(hibernateEvent, grailsEvent);
}
 

@Override
public void onPostInsert( PostInsertEvent event )
{
    if ( IdentifiableObject.class.isInstance( event.getEntity() )
        && MetadataObject.class.isInstance( event.getEntity() )
        && !EmbeddedObject.class.isInstance( event.getEntity() ) )
    {
        StatelessSession session = event.getPersister().getFactory().openStatelessSession();
        session.beginTransaction();

        try
        {
            List<DeletedObject> deletedObjects = deletedObjectService
                .getDeletedObjects( new DeletedObjectQuery( (IdentifiableObject) event.getEntity() ) );

            deletedObjects.forEach( deletedObject -> session.delete( deletedObject ) );

            session.getTransaction().commit();
        }
        catch ( Exception ex )
        {
            log.error( "Failed to delete DeletedObject for:" + event.getEntity() );
            session.getTransaction().rollback();
        }
        finally
        {
            session.close();
        }
    }
}
 

@Override
public void onPostInsert( PostInsertEvent postInsertEvent )
{
    Object entity = postInsertEvent.getEntity();

    getAuditable( entity, "create" ).ifPresent( auditable ->
        auditManager.send( Audit.builder()
            .auditType( getAuditType() )
            .auditScope( auditable.scope() )
            .createdAt( LocalDateTime.now() )
            .createdBy( getCreatedBy() )
            .object( entity )
            .auditableEntity( new AuditableEntity( entity ) )
            .build() ) );
}
 

@Override
public void onPostInsert(PostInsertEvent event) {
	evictCache( event.getEntity(), event.getPersister(), event.getSession(), null );
}
 

@Override
public void onPostInsert(PostInsertEvent event) {
	Object entity = event.getEntity();
	callbackRegistry.postCreate( entity );
}
 

@Override
public void onPostInsertCommitFailed(PostInsertEvent pie) {
}
 

@Override
public void onPostInsertCommitFailed( PostInsertEvent event )
{
    log.debug( "onPostInsertCommitFailed: " + event );
}
 

@Override
public void onPostInsertCommitFailed( PostInsertEvent event )
{
    log.warn( "onPostInsertCommitFailed: " + event );
}