749 views
In this article, we will look at the various approaches to implementing pipeline blocks to conditionally execute.
As the pipeline framework executes pipeline blocks linearly, there may be instances where pipeline blocks registered to the pipeline should not be executed. For example, in the following pipeline both the Braintree and Gift Cards payments are registered in the IProcessPaymentsPipeline to capture payments, however the customer may have only paid with a single payment method.
IProcessPaymentsPipeline Sample.Payments.Braintree.CapturePaymentsBlock Sample.Payments.Finance.CapturePaymentsBlock Sample.Payments.GiftCards.CapturePaymentsBlock
To prevent unnecessary execution of pipeline blocks, the following approaches are discussed generically and not specific to the sample pipeline above.
The Pipeline Block
The PipelineBlock is the common abstract class that the majority of pipeline blocks are based off of. The Run method is where the business logic is placed and will be executed for the pipeline block. There is no mechanism to conditionally execute the business logic within its Run method, however we can simply achieve this by returning the pipeline early if a certain condition is not met.
The following example, simply checks to see if the cart has a FederatedPaymentComponent, otherwise it will return the pipeline argument to continue execution of the pipeline.
public class SamplePipelineBlock : PipelineBlock<SamplePipelineArgument, SamplePipelineArgument, CommercePipelineExecutionContext>
{
protected CommerceCommander Commander { get; set; }
public SamplePipelineBlock(CommerceCommander commander)
: base(null)
{
this.Commander = commander;
}
public override async Task<SamplePipelineArgument> Run(SamplePipelineArgument arg, CommercePipelineExecutionContext context)
{
Condition.Requires(arg).IsNotNull($"{this.Name}: The argument can not be null");
var cart = arg.Cart;
if (!cart.HasComponent<FederatedPaymentComponent>())
{
return await Task.FromResult(arg).ConfigureAwait(false);
}
/* Add business logic here */
return await Task.FromResult(arg).ConfigureAwait(false);
}
}
The ConditionalPipelineBlock
The ConditionalPipelineBlock is an abstract class that allows a custom pipeline block to be implemented with the BlockCondition Predicate, which will determine whether to execute the Run method, otherwise executing the ContinueTask method.
In Sitecore Commerce Project projects, this pipeline block implements concrete pipeline block by utilising the Run method as the standard housing for the business logic; the BlockCondition is implemented to determine whether a policy is available within the current environment or global environment, dependent on the context, and the ContinueTask to return the pipeline argument to continue the pipeline.
Note: The BlockCondition does not be determined by an environment policy, however consider whether another pipeline block approach may be more beneficial if implementing conditional logic alternate to an environment policy.
Note: It is strongly recommended that the ContinueTask simply returns the pipeline argument, but it is not mandatory. Consider alternative approaches, such as additional confitional pipeline blocks, prior to adding business logic in this method.
public class SampleConditionalPipelineBlock: ConditionalPipelineBlock<SamplePipelineArgument, SamplePipelineArgument, CommercePipelineExecutionContext>
{
public SampleConditionalPipelineBlock()
{
this.BlockCondition = ValidatePolicy;
}
private static bool ValidatePolicy(IPipelineExecutionContext context)
{
return ((CommercePipelineExecutionContext)context).CommerceContext.HasPolicy<SampleEnvironmentPolicy>();
}
public override Task<SamplePipelineArgument> Run(SamplePipelineArgument arg, CommercePipelineExecutionContext context)
{
Condition.Requires(arg).IsNotNull($"{this.Name}: argument can not be null.");
/* business logic here */
return Task.FromResult(arg);
}
public override Task<SamplePipelineArgument> ContinueTask(SamplePipelineArgument arg, CommercePipelineExecutionContext context)
{
return Task.FromResult(arg);
}
}
The PolicyTriggerConditionalPipelineBlock
The PolicyTriggerConditionalPipelineBlock is another abstract class, piggybacking off of the ConditionalPipelineBlock, introducing an abstract string ShouldNotRunPolicyTrigger, implementing the ContinueTask to return the pipeline argument my default, and implementing the BlockCondition to determine if a the pipeline block should run based on the ShouldNotRunPolicyTrigger value being present in the PolicyKeys request header property.
Tip: This approach may come in handy in custom integration import/export APIs.
public class SamplePolicyTriggerConditionalPipelineBlock : PolicyTriggerConditionalPipelineBlock<SamplePipelineArgument, SamplePipelineArgument>
{
public override string ShouldNotRunPolicyTrigger
{
get
{
return "IgnoreSample";
}
}
public override Task<SamplePipelineArgument> Run(SamplePipelineArgument arg, SamplePipelineArgument context)
{
Condition.Requires(arg).IsNotNull(this.Name + ": argument cannot be null.");
/* business logic here */
return Task.FromResult(arg);
}
}