Package com.broadleafcommerce.dataexchange.service

Class AbstractBatchItemHandler<T1 extends ExchangeObject,T2 extends ExchangeObject>

java.lang.Object
com.broadleafcommerce.dataexchange.service.AbstractBatchItemHandler<T1,T2>
All Implemented Interfaces:
BatchItemHandler<T1,T2>
Direct Known Subclasses:
ProductBatchItemHandler, ProductRelatedBatchItemHandler, ProductTagBatchItemHandler, VariantRelatedBatchItemHandler
public abstract class AbstractBatchItemHandler<T1 extends ExchangeObject,T2 extends ExchangeObject> extends Object implements BatchItemHandler<T1,T2>

  • Constructor Details

    • AbstractBatchItemHandler

      public AbstractBatchItemHandler(com.broadleafcommerce.common.extension.TypeFactory typeFactory)

  • Method Details

    • execute

      public CompletableFuture<Void> execute(T1 parent, ExchangeObject exchangeObject, BatchContext<T1> batchContext, org.springframework.core.task.AsyncTaskExecutor executor, org.springframework.retry.support.RetryTemplate retryTemplate)
      Description copied from interface: BatchItemHandler
      The entry point for the handler. Creates a CompletableFuture that will handle the item in the batch. By default, this executes the following steps:
      1. Execute the preHandleRunnable
      2. Execute the handleRunnable
      3. Execute the postHandleRunnable
      4. Execute the populateCorrelationIdRunnable
      AbstractBatchItemHandler contains an implementation, but users may override this method to customize the behavior. For example, if we're handling a product, we may want to execute additional futures after the product is handled.

      See class level documentation for important information about composing futures.

      Specified by:
      execute in interface BatchItemHandler<T1 extends ExchangeObject,T2 extends ExchangeObject>
      Parameters:
      parent - the parent object (e.g. ComprehensiveProduct). This is not the saved instance. See BatchContext.getSavedEntity(String)
      exchangeObject - the item in the batch
      batchContext - the batch context
      executor - the executor to use for the future
      retryTemplate - the retry template to use for the future
      Returns:
      a CompletableFuture that will handle the item in the batch
      See Also:

    • execute

      public CompletableFuture<Void> execute(T1 parent, ExchangeObject exchangeObject, BatchContext<T1> batchContext, org.springframework.core.task.AsyncTaskExecutor executor, org.springframework.retry.support.RetryTemplate retryTemplate, BatchItemOperationType operationType)
      Description copied from interface: BatchItemHandler
      The entry point for the handler. Supports the caller determining the operation type. Creates a CompletableFuture that will handle the item in the batch. By default, this executes the following steps:
      1. Execute the preHandleRunnable
      2. Execute the handleRunnable
      3. Execute the postHandleRunnable
      4. Execute the populateCorrelationIdRunnable
      This method is used when the caller needs to specify the operation type. For example, the product handler is responsible for determining creates/updates/deletes of its children. If the handler is capable of determining the operation type itself and doesn't have any child related entities, the implementation in AbstractBatchItemHandler#execute(T1, ExchangeObject, BatchContext, AsyncTaskExecutor, RetryTemplate) is likely sufficient and the operation type may be determined in the BatchItemHandler.preHandle(HandlerArgs) step.

      See class level documentation for important information about composing futures.

      Specified by:
      execute in interface BatchItemHandler<T1 extends ExchangeObject,T2 extends ExchangeObject>
      Parameters:
      parent - the parent object (e.g. ComprehensiveProduct). This is not the saved instance. See BatchContext.getSavedEntity(String)
      exchangeObject - the item in the batch
      batchContext - the batch context
      executor - the executor to use for the future
      retryTemplate - the retry template to use for the future
      Returns:
      a CompletableFuture that will handle the item in the batch

    • execute

      public CompletableFuture<Void> execute(T1 parent, ExchangeObject exchangeObject, BatchContext<T1> batchContext, org.springframework.core.task.AsyncTaskExecutor executor, org.springframework.retry.support.RetryTemplate retryTemplate, Map<String,Object> additionalArgs)
      Description copied from interface: BatchItemHandler
      The entry point for the handler. Creates a CompletableFuture that will handle the item in the batch. By default, this executes the following steps:
      1. Execute the preHandleRunnable
      2. Execute the handleRunnable
      3. Execute the postHandleRunnable
      4. Execute the populateCorrelationIdRunnable
      AbstractBatchItemHandler contains an implementation, but users may override this method to customize the behavior. For example, if we're handling a product, we may want to execute additional futures after the product is handled.

      See class level documentation for important information about composing futures.

      Specified by:
      execute in interface BatchItemHandler<T1 extends ExchangeObject,T2 extends ExchangeObject>
      Parameters:
      parent - the parent object (e.g. ComprehensiveProduct). This is not the saved instance. See BatchContext.getSavedEntity(String)
      exchangeObject - the item in the batch
      batchContext - the batch context
      executor - the executor to use for the future
      retryTemplate - the retry template to use for the future
      additionalArgs - additional arguments to pass to the handler.
      Returns:
      a CompletableFuture that will handle the item in the batch
      See Also:

    • execute

      public CompletableFuture<Void> execute(T1 parent, ExchangeObject exchangeObject, BatchContext<T1> batchContext, org.springframework.core.task.AsyncTaskExecutor executor, org.springframework.retry.support.RetryTemplate retryTemplate, BatchItemOperationType operationType, Map<String,Object> additionalArgs)
      Description copied from interface: BatchItemHandler
      The entry point for the handler. Supports the caller determining the operation type. Creates a CompletableFuture that will handle the item in the batch. By default, this executes the following steps:
      1. Execute the preHandleRunnable
      2. Execute the handleRunnable
      3. Execute the postHandleRunnable
      4. Execute the populateCorrelationIdRunnable
      This method is used when the caller needs to specify the operation type. For example, the product handler is responsible for determining creates/updates/deletes of its children. If the handler is capable of determining the operation type itself and doesn't have any child related entities, the implementation in AbstractBatchItemHandler#execute(T1, ExchangeObject, BatchContext, AsyncTaskExecutor, RetryTemplate) is likely sufficient and the operation type may be determined in the BatchItemHandler.preHandle(HandlerArgs) step.

      See class level documentation for important information about composing futures.

      Specified by:
      execute in interface BatchItemHandler<T1 extends ExchangeObject,T2 extends ExchangeObject>
      Parameters:
      parent - the parent object (e.g. ComprehensiveProduct). This is not the saved instance. See BatchContext.getSavedEntity(String)
      exchangeObject - the item in the batch
      batchContext - the batch context
      executor - the executor to use for the future
      retryTemplate - the retry template to use for the future
      operationType - the operation type
      additionalArgs - additional arguments to pass to the handler.
      Returns:
      a CompletableFuture that will handle the item in the batch

    • createFutureInternal

      protected CompletableFuture<Void> createFutureInternal(HandlerArgs<T1,T2> args)
      Create a completable future that will apply the preHandle, handle, postHandle, and createSupplementalFutures methods.
      Parameters:
      args - the handler arguments
      Returns:
      the completable future

    • applyHandle

      protected CompletableFuture<Void> applyHandle(HandlerArgs<T1,T2> args, org.springframework.core.task.AsyncTaskExecutor executor, org.springframework.retry.support.RetryTemplate retryTemplate, CompletableFuture<Void> result)
      Create a completable future that will apply the handle method. If performing more complex operations that require multiple steps that need to be executed, this is most likely the method that should be overridden.
      Parameters:
      args - the handler arguments
      executor - the executor to run the completable future
      retryTemplate - the retry template to use
      result - the completable future to apply the handle method to
      Returns:
      the completable future

    • applyPostOperations

      protected CompletableFuture<Void> applyPostOperations(HandlerArgs<T1,T2> args, CompletableFuture<Void> future)
      Applies the postHandle and populateCorrelationId methods.
      Parameters:
      args - the handler arguments
      future - the completable future to apply the post operations to
      Returns:
      the completable future

    • buildTranslationMap

      protected Map<Locale,List<Translation>> buildTranslationMap(T2 beforeSaveItem, @Nullable String entityId)
      Build a map of translations for the given translations, keyed by locale. The entity ID and entity type will be set on each translation. The translations object on the Translatable must not be null.
      Returns:
      a map of translations keyed by locale

    • isNewlyCreated

      protected boolean isNewlyCreated(HandlerArgs<?,?> args)
      Returns true if this is a newly created item or if the saved item is null.
      Parameters:
      args - the handler arguments
      Returns:
      true if this is a newly created item or if HandlerArgs.getSavedItem() is null

    • getSavedTopLevel

      protected T1 getSavedTopLevel(HandlerArgs<T1,T2> args)

    • getTypeFactory

      protected com.broadleafcommerce.common.extension.TypeFactory getTypeFactory()