Passing variables / arguments between repeated Activities in MassTransit Courier Routing Slips - masstransit

Question

I'm looking to integrate the MassTransit Courier Routing Slip features into an existing solution using Azure Functions and ServiceBusTriggers that synchronizes data between two systems, and has to use a SOAP HTTP client. However, I'm struggling to understand how arguments and variables passed between activities are prioritized. This is best explained via a poor mock example itinerary. My assumption was that variables override existing arguments, but I think that was an incorrect assumption.
public class SyncCustomerOrderConsumer : IConsumer<SyncCustomerOrderMessage>
{
public async Task Consume(ConsumeContext<SyncCustomerOrderMessage> context)
{
var slip = this.BuildRoutingSlip(context.Message);
await context.Execute(slip);
}
private RoutingSlip BuildRoutingSlip(SyncCustomerOrderMessage args)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
builder.AddVariable("OrderItems", args.OrderItems);
builder.AddActivity(nameof(SyncCustomerActivity), GetActivityCustomer<SyncCustomerActivity, SyncCustomerArgs>() new {
args.Customer
});
builder.AddActivity(nameof(SyncCustomerActivity), GetActivityCustomer<SyncCustomerActivity, SyncCustomerArgs>() new {
args.ShippingAddress
});
builder.AddActivity(nameof(SyncOrderActivity), GetActivityCustomer<SyncOrderActivity, SyncOrderArgs>() new {
args.Order
});
foreach (var item in args.OrderItems)
{
builder.AddActivity(nameof(SyncOrderItemActivity), GetActivityCustomer<SyncOrderItemActivity, SyncOrderItemArgs>(), new
{
OrderItem = args.item
});
}
builder.AddActivity(nameof(SyncSourceActivity), GetActivityCustomer<SyncSourceActivity, SyncSourceArgs>());
return builder.Build();
}
}
public class SyncOrderItemActivity : IExecuteActivity<SyncOrderItemArgs>
{
private readonly IOrderItemWebserviceClient _client;
privater readonly IMapper _mapper;
public SyncOrderItemActivity(IOrderItemWebserviceClient client, IMapper mapper)
{
_client = client;
_mapper = mapper;
}
public async Task<ExecutionResult> Execute(ExecuteContext<SyncOrderItemArgs> context)
{
var args = context.Arguments;
var dto = _mapper.Map<OrderItemDto>(args);
if (args.OrderItem.External.IsNotSynced())
{
var response = await _client.AddAsync(dto);
args.OrderItem.ExternalId = response.Uuid;
args.OrderItem.LastSynced = response.LastUpdated;
}
else
{
var response = await _client.UpdateAsync(dto);
args.OrderItem.LastSynced = response.LastUpdated;
}
// replace the existing order items variable
int index = args.OrderItems.FindIndex(oi => oi.Id == args.OrderItem.Id);
if (index != 1)
args.OrderItems[index] = orderItem;
return context.CompletedWithVariables(new { OrderItem = args.OrderItem, OrderItems = args.OrderItems });
}
}
public class SyncOrderItemArgs
{
public OrderItem OrderItem { get; set; }
public List<OrderItem> OrderItems { get; set; }
}
public class SyncSourceActivity : IExecuteActivity<SyncSourceArgs>
{
private readonly IEventGridClient _client;
privater readonly IMapper _mapper;
public SyncSourceActivity(IEventGridClient client, IMapper mapper)
{
_client = client;
_mapper = mapper;
}
public async Task<ExecutionResult> Execute(ExecuteContext<SyncSourceArgs> context)
{
var args = context.Arguments;
// this is the original list, not the replaced list
foreach (var item in args.OrderItems)
{
await _client.PublishAsync(new OrderItemSyncedEvent { item });
}
return context.Completed();
}
}
public class SyncCustomerOrderMessage
{
public Customer Customer { get; set; }
public Order Order { get; set; }
public List<OrderItem> OrderItems { get; set; }
public Address ShippingAddress { get; set; }
}
The problem here is that the list of activities to deal with each OrderItem is defined as an argument and updated in each call to that SynOrderItemactivity. As the individual item is processed, it is supposed to replace the original item in the list and then pass the entire altered list as a variable into the next iteration of the same activity. However, the list is not the altered list, but the original one.
I guess my question is two-fold:
How do should you best design a routing slip that has a a list if the same activity, where some of the arguments have to be defined, but others are expected to come from the variable?
When it comes to arguments and variables, which ones take priority?

Answer 1

Unknown? I'm not even sure what this question is asking.
Arguments first, variables second. Explicitly specified arguments when adding the activity to the itinerary take precedence, missing arguments are pulled from variables if present, or left at the default/null value.