Hybris business process polling

Question

I need to create an action in my custom business process that must be executed every 10 minutes until an specific action is returned, is there any way to customize the polling interval of an action in hybris order business process? I know that you can configure a timeout but not a polling interval:

<wait id='waitForOrderConfirmation' then='checkOrder' prependProcessCode='true'>
<event>confirm</event>
<timeout delay='PT12H' then='asmCancelOrder'/>

Answer 1

Need custom Implementation to achieve this and need to use BusinessProcessParameterModel.

Below are the steps to Make Retry based on Dealy.

Create RepeatableAction.

import de.hybris.platform.processengine.model.BusinessProcessModel;
import de.hybris.platform.processengine.model.BusinessProcessParameterModel;
import de.hybris.platform.servicelayer.model.ModelService;
import de.hybris.platform.warehousing.process.BusinessProcessException;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Optional;


public interface RepeatableAction<T extends BusinessProcessModel>
{
    int COUNTER_STARTER = 1;

    ModelService getModelService();

    Optional<Integer> extractThreshold(T process);

    String getParamName();

    default void increaseRetriesCounter(final T process)
    {
        final Collection<BusinessProcessParameterModel> contextParameters = process.getContextParameters();

        final Optional<BusinessProcessParameterModel> paramOptional = extractCounter(contextParameters);

        paramOptional.ifPresent(this::incrementParameter);

        if (!paramOptional.isPresent())
        {
            final Collection<BusinessProcessParameterModel> newContextParameters = new ArrayList<>(contextParameters);

            final BusinessProcessParameterModel counter = getModelService().create(BusinessProcessParameterModel.class);
            counter.setName(getParamName());
            counter.setValue(COUNTER_STARTER);
            counter.setProcess(process);

            newContextParameters.add(counter);

            process.setContextParameters(newContextParameters);
            getModelService().save(process);
        }
    }

    default Optional<BusinessProcessParameterModel> extractCounter(
            final Collection<BusinessProcessParameterModel> contextParameters)
    {
        //@formatter:off
        return contextParameters.stream().filter(p -> getParamName().equals(p.getName())).findFirst();
        //@formatter:on
    }

    default void incrementParameter(final BusinessProcessParameterModel parameter)
    {
        final Object value = parameter.getValue();
        if (value instanceof Integer)
        {
            parameter.setValue((Integer) value + 1);

            getModelService().save(parameter);
        }
        else
        {
            //@formatter:off
            final String message = MessageFormat.format("Wrong process parameter '{}' type. {} expected, {} actual.", getParamName(),
                    Integer.class.getSimpleName(), value.getClass().getSimpleName());
            //@formatter:on

            throw new BusinessProcessException(message);
        }
    }

    default boolean retriesCountThresholdExceeded(final T process)
    {
        //@formatter:off
        final Optional<Integer> counterOptional = extractCounter(process.getContextParameters())
                .map(BusinessProcessParameterModel::getValue).filter(Integer.class::isInstance).map(Integer.class::cast);
        //@formatter:on

        final Optional<Integer> thresholdOptional = extractThreshold(process);

        final boolean counterSet = counterOptional.isPresent();
        final boolean thresholdSet = thresholdOptional.isPresent();

        boolean thresholdExceeded = false;

        if (counterSet && thresholdSet)
        {
            final int counter = counterOptional.get();
            final int threshold = thresholdOptional.get();
            thresholdExceeded = counter > threshold;
        }

        return counterSet && thresholdSet && thresholdExceeded;
    }
}

Then Go to Custom Action and Implement This Interface and based on some condition make custom Transition as RETRY, something like this.

public class CustomAction extends AbstractAction<OrderProcessModel>
        implements RepeatableAction<OrderProcessModel>
        {
        
        private static final int MAX_RETRIES = 3;//make it configurable it's your choice
        @Override
    public Transition prepare(OrderModel order, OrderProcessModel process)
    {
        if (!retriesCountThresholdExceeded(process))
        {
            if (custom condition)
            {
                return Transition.OK;
            }
            getModelService().refresh(order);
            increaseRetriesCounter(process);
            return Transition.RETRY;
        }
        return Transition.NOK;
    }
        
        }
        
        @Override
    public Optional<Integer> extractThreshold(OrderProcessModel process)
    {
        return Optional.of(MAX_RETRIES);
    }

Then in process.xml Action entries should be like this.

<action id="customAction" bean="customAction">
        <transition name="OK" to="nextStep"/>
        <transition name="RETRY" to="waitForOrderConfirmation"/>
        <transition name="NOK" to="cancelOrderAction"/>
    </action>

<wait id='waitForOrderConfirmation' then='checkOrder' prependProcessCode='true'>
<event>confirm</event>
<timeout delay='PT12H' then='asmCancelOrder'/>
<wait>

NOTE: Please set dealy as per requirement as of new 12hr seems to be too much