Uses CustomEvents within ImportJobs

src/main/java/sirius/biz/importer/BaseImportHandler.java

@@ -122,6 +122,11 @@ protected E load(Context data, Mapping... mappings) {
  protected E load(Context data, E entity, Mapping... mappings) {
  Arrays.stream(mappings).forEach(mapping -> loadMapping(entity, mapping, data));
 
+ if (context.getEventDispatcher().isActive()) {
+ context.getEventDispatcher()
+ .handleEvent(new OnLoadEvent<E>(entity, data, Arrays.stream(mappings).toList(), context));
+ }
+
  enforcePostLoadConstraints(entity);
 
  return entity;

src/main/java/sirius/biz/importer/BeforeFindEvent.java

@@ -0,0 +1,33 @@
+/*
+ * Made with all the love in the world
+ * by scireum in Remshalden, Germany
+ *
+ * Copyright by scireum GmbH
+ * http://www.scireum.de - info@scireum.de
+ */
+
+package sirius.biz.importer;
+
+import sirius.db.mixing.Entity;
+import sirius.kernel.commons.Context;
+
+/**
+ * Triggered within {@link sirius.biz.importer.ImportHandler#tryFind(Context)} before the entity is actually being
+ * looked up.
+ *
+ * @param <E> the type of entity being looked up
+ */
+public class BeforeFindEvent<E extends Entity> extends ContextScriptableEvent<E> {
+
+ /**
+ * Creates a new event for the given entity type, context and import context.
+ *
+ * @param entityType the type of entities being looked up
+ * @param context the context to read data from. Note that this can and should be modified by the handler,
+ * as this is the whole purpose of this event anyway.
+ * @param importerContext the import context which can be used to access other handlers / the importer itself
+ */
+ public BeforeFindEvent(Class<E> entityType, Context context, ImporterContext importerContext) {
+ super(entityType, context, importerContext);
+ }
+}

src/main/java/sirius/biz/importer/ContextScriptableEvent.java

@@ -0,0 +1,61 @@
+/*
+ * Made with all the love in the world
+ * by scireum in Remshalden, Germany
+ *
+ * Copyright by scireum GmbH
+ * http://www.scireum.de - info@scireum.de
+ */
+
+package sirius.biz.importer;
+
+import sirius.biz.scripting.TypedScriptableEvent;
+import sirius.kernel.commons.Context;
+
+/**
+ * Provides a base implementation for all events which are scriptable and have a context / import context
+ *
+ * @param <E> the generic type of entities being handled
+ */
+public abstract class ContextScriptableEvent<E> extends TypedScriptableEvent<E> {
+
+ private final Class<E> entityType;
+ private final Context context;
+ private final ImporterContext importerContext;
+
+ /**
+ * Creates a new event for the given entity type, context and import context.
+ *
+ * @param entityType the type of entity being handled
+ * @param context the context to read data from. Note that this can and should be modified by the handler,
+ * as this is the whole purpose of this event anyway.
+ * @param importerContext the import context which can be used to access other handlers / the importer itself
+ */
+ @SuppressWarnings("AssignmentOrReturnOfFieldWithMutableType")
+ protected ContextScriptableEvent(Class<E> entityType, Context context, ImporterContext importerContext) {
+ this.entityType = entityType;
+ this.context = context;
+ this.importerContext = importerContext;
+ }
+
+ /**
+ * Returns the context which contains the data of the current event.
+ * <p>
+ * Note that this is mutable by design, as the handler will most probably want to modify the context
+ * before it is processed by the import handler
+ *
+ * @return the context containing the actual data being imported
+ */
+ @SuppressWarnings("AssignmentOrReturnOfFieldWithMutableType")
+ public Context getContext() {
+ return context;
+ }
+
+ public ImporterContext getImporterContext() {
+ return importerContext;
+ }
+
+ @Override
+ public Class<E> getType() {
+ return entityType;
+ }
+}

src/main/java/sirius/biz/importer/MongoEntityImportHandler.java

@@ -71,8 +71,14 @@ protected void collectDefaultExportableMappings(BiConsumer<Integer, Mapping> col
  // via @Exportable
  }
 
+ @SuppressWarnings("unchecked")
  @Override
  public final Optional<E> tryFind(Context data) {
+ if (context.getEventDispatcher().isActive()) {
+ context.getEventDispatcher()
+ .handleEvent(new BeforeFindEvent<E>((Class<E>) descriptor.getType(), data, context));
+ }
+
  return findByExample(data);
  }
 

src/main/java/sirius/biz/importer/OnLoadEvent.java

@@ -0,0 +1,52 @@
+/*
+ * Made with all the love in the world
+ * by scireum in Remshalden, Germany
+ *
+ * Copyright by scireum GmbH
+ * http://www.scireum.de - info@scireum.de
+ */
+
+package sirius.biz.importer;
+
+import sirius.db.mixing.BaseEntity;
+import sirius.db.mixing.Entity;
+import sirius.db.mixing.Mapping;
+import sirius.kernel.commons.Context;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Triggered within {@link sirius.biz.importer.ImportHandler#load(Context, BaseEntity)} in order to update an entity
+ * using the given context.
+ *
+ * @param <E> the type of entity being updated
+ */
+public class OnLoadEvent<E extends Entity> extends ContextScriptableEvent<E> {
+ private final E entity;
+ private final List<Mapping> mappingsToLoad;
+
+ /**
+ * Creates a new event for the given entity
+ *
+ * @param entity the entity to update
+ * @param context the context to read data from. Note that this can and should be modified by the handler,
+ * as this is the whole purpose of this event anyway.
+ * @param mappingsToLoad the mappings to load from the given context
+ * @param importerContext the import context which can be used to access other handlers / the importer itself
+ */
+ @SuppressWarnings("unchecked")
+ public OnLoadEvent(E entity, Context context, List<Mapping> mappingsToLoad, ImporterContext importerContext) {
+ super((Class<E>) entity.getClass(), context, importerContext);
+ this.entity = entity;
+ this.mappingsToLoad = Collections.unmodifiableList(mappingsToLoad);
+ }
+
+ public E getEntity() {
+ return entity;
+ }
+
+ public List<Mapping> getMappingsToLoad() {
+ return mappingsToLoad;
+ }
+}

src/main/java/sirius/biz/importer/SQLEntityImportHandler.java

@@ -153,8 +153,14 @@ public E load(Context data, E entity) {
  return load(data, entity, mappingsToLoad);
  }
 
+ @SuppressWarnings("unchecked")
  @Override
  public Optional<E> tryFind(Context data) {
+ if (context.getEventDispatcher().isActive()) {
+ context.getEventDispatcher()
+ .handleEvent(new BeforeFindEvent<E>((Class<E>) descriptor.getType(), data, context));
+ }
+
  E example = loadForFind(data);
  return tryFindByExample(example);
  }