It is the order line total I'm after.

More specific: if the sum of the order line total of all order lines with a certain property is above a specific amount I need to add a fee to the order.

Hi Soren,

Ok, in the situation then, I think you might need to extend the price calculator pipeline.

We don't have a lot of docs around this at the moment, but hopefully this will explain what you need to do.

So the price calculator pipeline is a series of tasks that are run in sequence in order to calculate the Order total. With this pipeline, it's also possible to add your own tasks into it so you can alter how the order is calculated. In your situation, I think given you want to apply the fee at the order level, you'll want to add a task into the CalculateOrderPrices pipeline.

The first thing you'll need to do is define a pipeline task, which will look like the following:

public class MyOrderCalculationPipelineTask : PipelineTaskWithTypedArgsBase<OrderCalculationPipelineArgs, OrderCalculation>
{
    public override PipelineResult<OrderCalculation> Execute(OrderCalculationPipelineArgs args)
    {
        /// Do your thing

        return Ok(args.Model);
    }
}

Inside this method you can modify the calculation. The calculation is at this point held seperate to the Order as we calculate everything in a pipeline and then apply it to the Order at the end. So, all the prices you might want to modify will be held in args.Calculation. For your situation I think you'll want to update the args.Calculation.TotalPrice.WithoutDiscounts.

In the args object you'll also get access to the current Order via args.Order so from there you can loop over order lines looking for the ones that contain the property you need. Remember though, those OrderLines haven't currently been updated with the newly calculated prices yet so once you have found the order lines you are interested in, you will want to look up their calculated prices in the args.Calculation.OrderLines property which is a Dictionary accepting an OrderLineId as it's key, and it's value is that order lines current calculation.

So, from here you can loop through the order line prices and work out which ones exceed your limit and then keep a running fee total, and after this, you can append that fee to the args.Calculation.TotalPrice.WithoutDiscounts value.

Ok, so now you have a task, you'll need to inject it into the pipeline. For this you'll need to have a composer defined inside which you'll need to register your task as follows:

composition.WithCalculateOrderPricesPipeline()
    .InsertAfter<CalculateOrderTotalPriceWithoutDiscountTask, MyOrderCalculationPipelineTask>();

For your situation I think you'll want to register your task after the built in CalculateOrderTotalPriceWithoutDiscountTasktask which calculates the TotalPrice.WithoutDiscounts value, from which you can append your fee, then things like discounts apply after this.

Essentially above then, this is injecting your task to run after the CalculateOrderTotalPriceWithoutDiscountTask into the order calculation pipeline.

And I think that's everything you should need to implement.

It's a lot to explain, but hopefully it will make sense to you in the implementation. The key points are

1. Extend the order pipeline by injecting a task
2. In the task, you can access the order via args.Order
3. Don't use any prices on the Order object, instead use the current args.Calculation for the in progress calculation values

/Matt

PS we do have some docs on the Pipelines concept, but it doesn't hold the detail mentioned above (it may still help give some context)

https://vendr.net/docs/core/1-0-0/key-concepts/pipelines/

Hey Bjarne,

I think what you have so far is right. In terms of applying the fee you'll want to replace the existing args.Calculation.TotalPrice.WithoutDiscounts with the new price including fee like

args.Calculation.TotalPrice.WithoutDiscounts = Price.OfSameCurrency(args.Calculation.TotalPrice.WithoutDiscounts,
    args.Calculation.TotalPrice.WithoutDiscounts.WithoutTax + fee,
    args.Calculation.TotalPrice.WithoutDiscounts.Tax + feeTax);

Regarding showing this on the order, yea, I'm not sure we have anything in place for this at the moment. Technically the args.Order is a writable order just down-cast to a read only order, so for now, you probably could cast it to it's writable form and add a property to it (you shouldn't need to save the order at this point as it will get saved after the calculation).

Thinking about this from a higher level, I wonder if we need to introduce the concept of "Adjustments" to price objects where the price is calculated and these adjustments are applied and can also contain a label for it. Discounts and Gift Cards then could also become adjustments. When extending the pipelines it could then become easier as you could just add another adjustment to it.

I'll need to give that some thought, but for now, I think the above is how you'd need to go for the time being.

PS I haven't tried discounts with a negative value, but you could try it and see what happens. I think we may have some logic though which attempts to limit discounts so that could affect it, but I'm not quite sure.

Hey Bjarne,

As I said to Soren, the args.Calculation.OrderLines is the list of all order line calculation key'd by the order line. This is just the calculations though, so if you need properties from the order lines, you will need to loop through the order lines on the order, but then lookup the calculation based on the order line id

     // Get rental order lines
    var orderLines = order.OrderLines.Where(x => x.Properties["IsRental"]?.Value?.ToLower() == "true");

    var totalAmount = orderLines.Sum(x => args.Calculation.OrderLines[x.Id].TotalPrice.Value);

    if (totalAmount >= 2000)
    {
        var fee = 500M;
        var feeTax = fee * args.Calculation.TaxRate.Value;

        args.Calculation.TotalPrice.WithoutDiscounts = Price.OfSameCurrency(args.Calculation.TotalPrice.WithoutDiscounts,
            args.Calculation.TotalPrice.WithoutDiscounts.WithoutTax + fee,
            args.Calculation.TotalPrice.WithoutDiscounts.Tax + feeTax);
    }

(I haven't tested the above code, I'm just piecing it together based on the above posts)

RE applying discounts based on some logic, this is exactly what automatic discounts are. They automatically apply to an order if some rules match, so I guess you'd need to create a custom rule based upon your need.

Yes, I thought about this as well, as it could add/remove the product from the order based on a condition. Not sure if this approach also would use this pipeline task or something else.

However with this approach I think it by default show up when the other order lines, unless you exclude this order line. I think this would be more a fee similar to shipping and payment fees, so if shown on confirmation page, it would probably be listed below order lines, but I guess this depends on the use-case.

Yea, I think probably the route you are going will be what you need, it's just not the smoothest yet. You are the pioneers 😁

Hopefully the pipeline + order properties will do the trick for you for now but I have created an issue on github to track the idea of price adjustments here if you want to join the discussion https://github.com/vendrhub/vendr/issues/100

If I want to set a ordre property here in this pipeline task, what is the best approach?

It see I can do the following:

if (totalAmount >= 2000)
{
    // Add deposit fee to order
    ...

    args.AdditionalData.Add("DepositAmount", fee.ToString());
}
else
{
    args.AdditionalData.Remove("DepositAmount");
}

return Ok(args.Model);

Not sure what the purpose of AdditionalData property?

args.Order is an OrderReadOnly object and therefore Properties is readonly.

So it seems I need to do something like this to set order property

try
{
    using (var uow = _uowProvider.Create())
    {
        var o = args.Order.AsWritable(uow);

        o.SetProperty("DepositAmount", fee.ToString());

        uow.Complete();
    }
}
catch
{

}

As I mentioned previously, args.Order is already a writable order, it's just down-cast to OrderReadOnly so you should probably be able to do the following:

var writableOrder = (Order)args.Order;
writableOrder.SetProperty("DepositAmount", fee.ToString());

The args.AdditionalData is just a general data store for the pipeline itself in case any given pipeline task wants to store some data a later task in the pipeline might want to have access to. It bares no relevance on the order itself.

/Matt

Hi Matt

I doesn't seem to be possible to cast args.order (which is OrderReadOnly) to Order.

var writableOrder = (Order)args.Order;

It throw the following exception.

An object of type 'Vendr.Core.Models.OrderReadOnly' cannot be converted to type 'Vendr.Core.Models.Order'.

Tested with Vendr v1.1.3

Setting the property using IUnitOfWorkProviderapproach does work though and not necessary Save() using OrderService here.

Ahh, ok. Maybe I am converting it to ReadOnly rather than just casting it, in which the UOW approach should be fine.