public async Task Execute(ConsumeContext <IDeleteUserCommand> context)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
var deleteUserCommand = context.Message;
builder.AddActivity(UserServiceConstants.ActivityDeleteAdUser, _activityConfigurator.GetActivityExecuteUri(context, typeof(IDeleteActiveDirectoryUserActivity)), _activityArgumentsMapper.MapDeleteActiveDirectoryUserArguments(deleteUserCommand));
builder.AddActivity(UserServiceConstants.ActivityDeleteIsUser, _activityConfigurator.GetActivityExecuteUri(context, typeof(IDeleteIdentityServerUserActivity)), _activityArgumentsMapper.MapDeleteIdentityServerUserArguments(deleteUserCommand));
builder.AddSubscription(UserServiceConstants.RoutingSlipEventObserverUri,
RoutingSlipEvents.ActivityCompleted |
RoutingSlipEvents.ActivityFaulted |
RoutingSlipEvents.ActivityCompensated |
RoutingSlipEvents.ActivityCompensationFailed);
var user = _userService.GetUser(context.Message.UserId);
await builder.AddSubscription(Office365ServiceConstants.QueueOffice365UserRemoveLicenseUri,
RoutingSlipEvents.Completed,
x => x.Send <IOffice365UserRemoveLicenseCommand>(new
{
context.Message.CompanyId,
UserPrincipalName = user.Email
}));
var routingSlip = builder.Build();
await context.Execute(routingSlip);
}
public async Task Consume(ConsumeContext <SubmitOrder> context)
{
var routingSlipBuilder = new RoutingSlipBuilder(NewId.NextGuid());
var activityName = nameof(SaveOrderActivity).Replace("Activity", string.Empty);
var sanitizedName = KebabCaseEndpointNameFormatter.Instance.SanitizeName(activityName);
routingSlipBuilder.AddActivity(
activityName,
new Uri($"queue:{sanitizedName}_execute"),
new
{
context.Message.OrderId
}
);
var routingSlipAddress = new Uri($"rabbitmq://localhost/{KebabCaseEndpointNameFormatter.Instance.Consumer<RoutingSlipEventConsumer>()}");
routingSlipBuilder.AddSubscription(
routingSlipAddress,
RoutingSlipEvents.Completed
);
var routingSlip = routingSlipBuilder.Build();
await context.Execute(routingSlip);
if (context.RequestId != null)
{
await context.RespondAsync <OrderSubmissionAccepted>(new
{
InVar.Timestamp,
context.Message.OrderId
});
}
}
public async Task Execute(ConsumeContext <IOffice365ResendTxtRecordsCommand> context)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
var resendTxtRecordsCommand = context.Message;
builder.AddActivity(Office365ServiceConstants.ActivityGetOffice365CustomerTxtRecords, _activityConfigurator.GetActivityExecuteUri(context, typeof(IGetCustomerDomainTxtRecordsActivity)), _activityOffice365CustomerArgumentsMapper.MapGetCustomerTxtRecords(resendTxtRecordsCommand));
builder.AddActivity(Office365ServiceConstants.ActivitySendOffice365CustomerTxtRecords, _activityConfigurator.GetActivityExecuteUri(context, typeof(ISendCustomerDomainTxtRecordsActivity)), _activityOffice365CustomerArgumentsMapper.MapSendCustomerTxtRecords(resendTxtRecordsCommand));
builder.AddSubscription(Office365ServiceConstants.QueueOffice365RoutingSlipEventUri,
RoutingSlipEvents.Completed |
RoutingSlipEvents.Faulted |
RoutingSlipEvents.ActivityCompleted |
RoutingSlipEvents.ActivityFaulted |
RoutingSlipEvents.ActivityCompensated |
RoutingSlipEvents.ActivityCompensationFailed);
var routingSlip = builder.Build();
await context.Send <IRoutingSlipStarted>(Office365ServiceConstants.QueueOffice365RoutingSlipStartedUri, new
{
builder.TrackingNumber,
CreateTimestamp = DateTime.UtcNow,
Arguments = context.Message,
WorkflowActivityType = WorkflowActivityType.ResendOffice365DomainTxtRecords.ToString()
});
await context.Execute(routingSlip);
}
public async Task ExecuteRequest(ConsumeContext <ProcessRequest> context)
{
try
{
// podemos criar o build dependendo do tipo de context
var builder = new RoutingSlipBuilder(NewId.NextGuid());
builder.AddActivity(ConfigurationManager.AppSettings["CreateTaskActivityName"], new Uri(ConfigurationManager.AppSettings["CreateTaskExecuteAddress"]));
builder.AddActivity(ConfigurationManager.AppSettings["IdentifyProductsActivityName"], new Uri(ConfigurationManager.AppSettings["IdentifyProductsExecuteAddress"]));
builder.AddActivity(ConfigurationManager.AppSettings["SendToExternalActivityName"], new Uri(ConfigurationManager.AppSettings["SendToExternalExecuteAddress"]));
builder.SetVariables(new
{
Id = context.Message.Id,
Tenant = context.Message.Tenant
});
var routingSlip = builder.Build();
await context.Execute(routingSlip);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task Execute(ConsumeContext <IUpdateUserCommand> context)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
var updateUserCommand = context.Message;
builder.AddActivity(UserServiceConstants.ActivityUpdateAdUser, _activityConfigurator.GetActivityExecuteUri(context, typeof(IUpdateActiveDirectoryUserActivity)), _activityArgumentsMapper.MapActiveDirectoryUserArguments(updateUserCommand));
builder.AddActivity(UserServiceConstants.ActivityUpdateIsUser, _activityConfigurator.GetActivityExecuteUri(context, typeof(IUpdateIdentityServerUserActivity)), _activityArgumentsMapper.MapIdentityServerUserArguments(updateUserCommand));
builder.AddSubscription(UserServiceConstants.RoutingSlipEventObserverUri,
RoutingSlipEvents.Completed |
RoutingSlipEvents.Faulted |
RoutingSlipEvents.ActivityCompleted |
RoutingSlipEvents.ActivityFaulted |
RoutingSlipEvents.ActivityCompensated |
RoutingSlipEvents.ActivityCompensationFailed);
var routingSlip = builder.Build();
await context.Send <IRoutingSlipStarted>(UserServiceConstants.RoutingSlipUserStartedEventUri, new
{
builder.TrackingNumber,
CreateTimestamp = DateTime.UtcNow,
Arguments = context.Message,
WorkflowActivityType = WorkflowActivityType.UpdateUser.ToString()
});
await context.Execute(routingSlip);
}
public async Task Consume(ConsumeContext <IFulfillOrder> context)
{
_logger.LogInformation($"Fulfilled order {context.Message.OrderId}");
var builder = new RoutingSlipBuilder(NewId.NextGuid());
var order = await _orderService.GetOrderAsync(context.Message.OrderId);
builder.AddActivity("SubmitOrder", QueueNames.GetActivityUri(nameof(SubmitOrderActivity)));
builder.AddActivity("ReserveProducts", QueueNames.GetActivityUri(nameof(ReserveProductsActivity)), new
{
order.OrderItems
});
builder.AddActivity("Payment", QueueNames.GetActivityUri(nameof(PaymentActivity)));
builder.AddActivity("Delivery", QueueNames.GetActivityUri(nameof(DeliveryActivity)));
builder.AddVariable("CorrelationId", context.Message.CorrelationId);
builder.AddVariable("OrderId", context.Message.OrderId);
await builder.AddSubscription(context.SourceAddress,
RoutingSlipEvents.Faulted | RoutingSlipEvents.Supplemental,
RoutingSlipEventContents.None, x => x.Send <IOrderFulfillFaultedEvent>(new { context.Message.OrderId }));
await builder.AddSubscription(context.SourceAddress,
RoutingSlipEvents.Completed | RoutingSlipEvents.Supplemental,
RoutingSlipEventContents.None, x => x.Send <IOrderFulfillCompletedEvent>(new { context.Message.OrderId }));
var routingSlip = builder.Build();
await context.Execute(routingSlip).ConfigureAwait(false);
}
public async Task Consume(ConsumeContext <ExecuteActivities> context)
{
// Инициация RoutingSlip
var builder = new RoutingSlipBuilder(NewId.NextGuid());
// Операция списания денежных средств
builder.AddActivity(
nameof(ProcessOutflowActivity),
new Uri("queue:process-outflow_execute"),
new
{
AccountId = context.Message.SourceAccountId,
context.Message.Sum,
context.Message.CorrelationId
});
// Операция зачисления денежных средств
builder.AddActivity(
nameof(ProcessInflowActivity),
new Uri("queue:process-inflow_execute"),
new
{
AccountId = context.Message.TargetAccountId,
context.Message.Sum,
context.Message.CorrelationId
});
await context.Execute(builder.Build());
}
public async Task Consume(ConsumeContext <SubmitOrder> context)
{
LogContext.Info?.Log("Submitting Order: {OrderId}", context.Message.OrderId);
using (var client = new HttpClient())
await client.GetAsync("https://www.google.com");
var builder = new RoutingSlipBuilder(NewId.NextGuid());
if (!EndpointConvention.TryGetDestinationAddress <ProcessOrderArguments>(out var activityAddress))
{
throw new ConfigurationException("No endpoint address for activity");
}
builder.AddActivity("Process", activityAddress);
if (!EndpointConvention.TryGetDestinationAddress <OrderProcessed>(out var eventAddress))
{
throw new ConfigurationException("No endpoint address for activity");
}
await builder.AddSubscription(eventAddress, RoutingSlipEvents.Completed, endpoint =>
endpoint.Send <OrderProcessed>(context.Message));
await context.Execute(builder.Build());
await context.Publish <OrderSubmitted>(context.Message, x => x.ResponseAddress = context.ResponseAddress);
}
public async Task Consume(ConsumeContext <ProcessRegistration> context)
{
_log.InfoFormat("Processing registration: {0} ({1})", context.Message.SubmissionId, context.Message.ParticipantEmailAddress);
var routingSlip = CreateRoutingSlip(context);
await context.Execute(routingSlip).ConfigureAwait(false);
}
public async Task Consume(ConsumeContext <IProcessRegistration> context)
{
WriteLine("Processing registration: {0} ({1})", context.Message.SubmissionId, context.Message.ParticipantEmailAddress);
var routingSlip = CreateRoutingSlip(context);
await context.Execute(routingSlip);
}
public async Task Execute(ConsumeContext <IOffice365VerifyDomainCommand> context)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
var command = context.Message;
builder.AddActivity(Office365ServiceConstants.ActivityVerifyCustomerDomain,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IVerifyCustomerDomainActivity)),
_activityOffice365CustomerArgumentsMapper.MapVerifyCustomerDomain(command));
builder.AddActivity(Office365ServiceConstants.ActivityCreateTempAdminUser,
_activityConfigurator.GetActivityExecuteUri(context, typeof(ICreateTempPartnerPlatformAdminUserActivity)),
_activityOffice365CustomerArgumentsMapper.MapCreateTempAdminUser(command));
builder.AddActivity(Office365ServiceConstants.ActivityAssignUserRoles,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IAssignUserRolesActivity)),
_activityOffice365CustomerArgumentsMapper.MapAssignUserRoles(command));
builder.AddActivity(Office365ServiceConstants.ActivityFederateCustomerDomain,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IFederateCustomerDomainActivity)),
_activityOffice365CustomerArgumentsMapper.MapFederateCustomerDomain(command));
builder.AddActivity(Office365ServiceConstants.ActivityVerifyCustomerDomainDatabaseStatus,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IVerifyCustomerDomainDatabaseStatusActivity)),
_activityOffice365CustomerArgumentsMapper.MapVerifyCustomerDomainDatabaseStatus(command));
builder.AddActivity(Office365ServiceConstants.ActivityFederateCustomerDomainDatabaseStatus,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IFederateCustomerDomainDatabaseStatusActivity)),
_activityOffice365CustomerArgumentsMapper.MapFederateCustomerDomainDatabaseStatus(command));
builder.AddActivity(Office365ServiceConstants.ActivityHardDeletePartnerPlatformUser,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IHardDeletePartnerPlatformUserActivity)),
_activityOffice365CustomerArgumentsMapper.MapDeleteTempAdminUser(command));
builder.AddVariable("domainName", context.Message.DomainName);
builder.AddVariable("workflowActivityType", WorkflowActivityType.VerifyAndFederateOffice365Domain.ToString());
builder.AddSubscription(Office365ServiceConstants.QueueOffice365RoutingSlipEventUri,
RoutingSlipEvents.Faulted |
RoutingSlipEvents.Completed |
RoutingSlipEvents.ActivityCompleted |
RoutingSlipEvents.ActivityFaulted |
RoutingSlipEvents.ActivityCompensated |
RoutingSlipEvents.ActivityCompensationFailed);
var routingSlip = builder.Build();
await context.Send <IRoutingSlipStarted>(Office365ServiceConstants.QueueOffice365RoutingSlipStartedUri, new
{
builder.TrackingNumber,
CreateTimestamp = DateTime.UtcNow,
Arguments = context.Message,
WorkflowActivityType = WorkflowActivityType.VerifyAndFederateOffice365Domain.ToString()
});
await context.Execute(routingSlip);
}
public async Task Consume(ConsumeContext <ProcessOrderPayment> context)
{
RoutingSlipBuilder builder = new RoutingSlipBuilder(context.Message.CommandId);
builder.AddActivity("LoyaltyPayment", new Uri("loopback://localhost/loyalty-payment-execute"), new { });
builder.SetVariables(new { context.Message.Order });
await context.Execute(builder.Build());
}
public async Task Execute(ConsumeContext <IOffice365CreateCustommerCommand> context)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
var createOffice365CustommerCommand = context.Message;
builder.AddActivity(Office365ServiceConstants.ActivityCreateOffice365PartnerPlatformCustomer,
_activityConfigurator.GetActivityExecuteUri(context, typeof(ICreatePartnerPlatformCustomerActivity)),
_activityOffice365CustomerArgumentsMapper.MapCreatePartnerPlatformCustomerArguments(createOffice365CustommerCommand));
builder.AddActivity(Office365ServiceConstants.ActivityCreateOffice365DatabaseCustomer,
_activityConfigurator.GetActivityExecuteUri(context, typeof(ICreateDatabaseCustomerActivity)),
_activityOffice365CustomerArgumentsMapper.MapCreateDatabaseCustomerArguments(createOffice365CustommerCommand));
builder.AddActivity(Office365ServiceConstants.ActivityAddOffice365CustomerDomainToPartnerPortal,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IAddCustomerDomainPartnerPortalActivity)),
_activityOffice365CustomerArgumentsMapper.MapAddCustomerDomainPartnerPortalArguments(createOffice365CustommerCommand));
builder.AddActivity(Office365ServiceConstants.ActivityAddOffice365CustomerDomainToDatabase,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IAddCustomerDomainToDatabaseActivity)),
_activityOffice365CustomerArgumentsMapper.MapAddCustomerDomainToDatabaseArguments(createOffice365CustommerCommand));
builder.AddActivity(Office365ServiceConstants.ActivityGetOffice365CustomerTxtRecords,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IGetCustomerDomainTxtRecordsActivity)),
_activityOffice365CustomerArgumentsMapper.MapGetCustomerTxtRecords(createOffice365CustommerCommand));
builder.AddActivity(Office365ServiceConstants.ActivitySendOffice365CustomerTxtRecords,
_activityConfigurator.GetActivityExecuteUri(context, typeof(ISendCustomerDomainTxtRecordsActivity)),
_activityOffice365CustomerArgumentsMapper.MapSendCustomerTxtRecords(createOffice365CustommerCommand));
builder.AddVariable("companyId", context.Message.CompanyId);
builder.AddVariable("workflowActivityType", WorkflowActivityType.Office365AddAdditionalDomain.ToString());
builder.AddSubscription(Office365ServiceConstants.QueueOffice365RoutingSlipEventUri,
RoutingSlipEvents.Completed |
RoutingSlipEvents.Faulted |
RoutingSlipEvents.ActivityCompleted |
RoutingSlipEvents.ActivityFaulted |
RoutingSlipEvents.ActivityCompensated |
RoutingSlipEvents.ActivityCompensationFailed);
var routingSlip = builder.Build();
await context.Send <IRoutingSlipStarted>(Office365ServiceConstants.QueueOffice365RoutingSlipStartedUri, new
{
builder.TrackingNumber,
CreateTimestamp = DateTime.UtcNow,
Arguments = context.Message,
WorkflowActivityType = WorkflowActivityType.CreateOffice365Customer.ToString()
});
await context.Execute(routingSlip);
}
public async Task Consume(ConsumeContext <ProcessBurgerOrder> context)
{
_logger.LogInformation($"ProcessBurgerOrderConsumer {context.Message.OrderId}");
// Use unique ID and decouple tracking ID from any other IDs (Order Id) from the routing slip.
// e.g we might execute a routing slip multiple times so we would want a new ID to track with.
var trackingId = NewId.NextGuid();
// Create this routing slip in a consumer so we can use retry/fault handling
var routingSlip = BuildRoutingSlip(context, trackingId);
await context.Execute(routingSlip).ConfigureAwait(false);
}
public async Task Consume(ConsumeContext <OrderPizzaMessage> ctx)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
builder.SetVariables(ctx.Message);
builder.AddActivity("ChargePayment", new Uri("queue:ChargePayment_execute"));
builder.AddActivity("MakePizza", new Uri("queue:MakePizza_execute"));
var routingSlip = builder.Build();
await ctx.Execute(routingSlip);
}
public async Task Execute(ConsumeContext <IOffice365TransitionCommand> context)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
var command = context.Message;
builder.AddActivity(Office365ServiceConstants.ActivityCreateOffice365DatabaseCustomer,
_activityConfigurator.GetActivityExecuteUri(context, typeof(ICreateDatabaseCustomerActivity)), _mapper.MapCreateDatabaseCustomerArguments(command));
builder.AddActivity(Office365ServiceConstants.ActivityAddMultiDomainToDatabase,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IAddMultiDomainToDatabaseActivity)), _mapper.MapAddMultiDomainToDatabaseArguments(command));
builder.AddActivity(Office365ServiceConstants.ActivityMultiPartnerPlatformCustomerSubscription,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IMultiPartnerPlatformCustomerSubscriptionActivity)), _mapper.MapMultiPartnerPlatformCustomerSubscriptionArguments(command));
builder.AddActivity(Office365ServiceConstants.ActivityMultiDatabaseCustomerSubscription,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IMultiDatabaseCustomerSubscriptionActivity)), _mapper.MapMultiDatabaseCustomerSubscriptionArguments(command));
builder.AddActivity(Office365ServiceConstants.ActivityDatabaseProvisionedStatusProvisioned,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IDatabaseProvisionedStatusProvisionedActivity)), _mapper.MapDatabaseProvisionedStatusProvisionedArguments(command));
builder.AddActivity(Office365ServiceConstants.ActivityTransitionDispatchCreatingUsers,
_activityConfigurator.GetActivityExecuteUri(context, typeof(ITransitionDispatchCreatingUsersActivity)), _mapper.MapTransitionDispatchCreatingUserArguments(command));
builder.AddSubscription(Office365ServiceConstants.QueueOffice365RoutingSlipEventUri,
RoutingSlipEvents.Completed |
RoutingSlipEvents.Faulted |
RoutingSlipEvents.ActivityCompleted |
RoutingSlipEvents.ActivityFaulted |
RoutingSlipEvents.ActivityCompensated |
RoutingSlipEvents.ActivityCompensationFailed);
var routingSlip = builder.Build();
await context.Send <IRoutingSlipStarted>(Office365ServiceConstants.QueueOffice365RoutingSlipStartedUri, new
{
builder.TrackingNumber,
CreateTimestamp = DateTime.UtcNow,
Arguments = context.Message,
WorkflowActivityType = WorkflowActivityType.Office365Transition.ToString()
});
await context.Send <IOffice365TransitionReportCommand>(Office365ServiceConstants.QueueOffice365TransitioReportUri, new
{
command.CompanyId,
command.ProductItems
});
await context.Execute(routingSlip);
}
public async Task Consume(ConsumeContext <FulfilOrder> context)
{
if (context.Message.CustomerNumber.StartsWith("INVALID"))
{
throw new InvalidOperationException("We tried, but the customer is invalid");
}
// if (context.Message.CustomerNumber.StartsWith("MAYBE"))
// {
// if (new Random().Next(100) > 50)
// throw new ApplicationException("We randomly exploded, so sad, much tear");
// }
var builder = new RoutingSlipBuilder(NewId.NextGuid());
builder.AddActivity("AllocateInventory", new Uri("queue:allocate-inventory_execute"), new AllocateInventory
{
ItemNumber = "Item123",
Quantity = 10.0m
});
builder.AddActivity("PaymentActivity", new Uri("queue:payment_execute"), new Payment
{
CardNumber = context.Message.PaymentCardNumber,
Amount = 99.95m
});
builder.AddVariable("OrderId", context.Message.OrderId);
await builder.AddSubscription(context.SourceAddress,
RoutingSlipEvents.Faulted | RoutingSlipEvents.Supplemental,
RoutingSlipEventContents.None, x => x.Send <OrderFulfillmentFaulted>(new OrderFulfillmentFaulted
{
OrderId = context.Message.OrderId,
Timestamp = InVar.Timestamp
}));
await builder.AddSubscription(context.SourceAddress,
RoutingSlipEvents.Completed | RoutingSlipEvents.Supplemental,
RoutingSlipEventContents.None, x => x.Send <OrderFulfillmentCompleted>(new OrderFulfillmentCompleted
{
OrderId = context.Message.OrderId,
Timestamp = InVar.Timestamp
}));
var routingSlip = builder.Build();
await context.Execute(routingSlip);
}
public async Task Consume(ConsumeContext <FulfillOrder> context)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
builder.AddActivity("AllocateInventory",
new Uri("queue:allocate-inventory_execute"),
new
{
ItemNumber = "ITEM123",
Quantity = 10.0m
});
builder.AddVariable(nameof(context.Message.OrderId), context.Message.OrderId);
var routingSlip = builder.Build();
await context.Execute(routingSlip);
}
public async Task Execute(ConsumeContext <ICreateCompanyCommand> context)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
var createCompanyCommand = context.Message;
builder.AddActivity(CompanyServiceConstants.ActivityCreateAdCompany, _activityConfigurator.GetActivityExecuteUri(context, typeof(ICreateActiveDirectoryComapnyActivity)), _activityCompanyArgumentsMapper.MapActiveDirectoryCompanyArguments(createCompanyCommand));
builder.AddActivity(CompanyServiceConstants.ActivityCreateDatabaseCompany, _activityConfigurator.GetActivityExecuteUri(context, typeof(ICreateDatabaseCompanyActivity)), _activityCompanyArgumentsMapper.MapDatabaseCompanyArguments(createCompanyCommand));
builder.AddActivity(CompanyServiceConstants.ActivityAssignCatalog, _activityConfigurator.GetActivityExecuteUri(context, typeof(IAssignCatalogActivity)), _activityCompanyArgumentsMapper.MapAssignCatalogArguments(createCompanyCommand));
if (createCompanyCommand.Company.Type == CompanyType.Reseller)
{
builder.AddActivity(CompanyServiceConstants.ActivityAddCallbackRedirectUri,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IAddCallbackRedirectUriActivity)),
new
{
Uri = createCompanyCommand.Company.ControlPanelSiteUrl,
createCompanyCommand.ClientDbId
});
}
builder.AddActivity(UserServiceConstants.ActivityCreateAdUser, _activityConfigurator.GetActivityExecuteUri(context, typeof(ICreateActiveDirectoryUserActivity)), _activityUserArgumentsMapper.MapActiveDirectoryUserArguments(createCompanyCommand));
builder.AddActivity(UserServiceConstants.ActivityCreateIsUser, _activityConfigurator.GetActivityExecuteUri(context, typeof(ICreateIdentityServerUserActivity)), _activityUserArgumentsMapper.MapIdentityServerUserArguments(createCompanyCommand));
builder.AddActivity(CompanyServiceConstants.ActivityCompanyCreated, _activityConfigurator.GetActivityExecuteUri(context, typeof(ICompanyCreatedActivity)), _activityCompanyArgumentsMapper.MapCreatedComapnySendEmailArguments(createCompanyCommand));
builder.AddSubscription(CompanyServiceConstants.RoutingSlipEventObserverUri,
RoutingSlipEvents.Completed |
RoutingSlipEvents.Faulted |
RoutingSlipEvents.ActivityCompleted |
RoutingSlipEvents.ActivityFaulted |
RoutingSlipEvents.ActivityCompensated |
RoutingSlipEvents.ActivityCompensationFailed);
var routingSlip = builder.Build();
await context.Send <IRoutingSlipStarted>(CompanyServiceConstants.RoutingSlipCompanyStartedEventUri, new
{
builder.TrackingNumber,
CreateTimestamp = DateTime.UtcNow,
Arguments = context.Message,
WorkflowActivityType = WorkflowActivityType.CreateCompany.ToString()
});
await context.Execute(routingSlip);
}
public async Task Consume(ConsumeContext <TRequest> context)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
builder.AddSubscription(context.ReceiveContext.InputAddress, RoutingSlipEvents.ActivityCompleted | RoutingSlipEvents.ActivityFaulted);
builder.AddVariable("RequestId", context.RequestId);
builder.AddVariable("ResponseAddress", context.ResponseAddress);
builder.AddVariable("FaultAddress", context.FaultAddress);
builder.AddVariable("Request", context.Message);
await BuildRoutingSlip(builder, context);
var routingSlip = builder.Build();
await context.Execute(routingSlip).ConfigureAwait(false);
}
public async Task BookMeeting(ConsumeContext <BookMeeting> context)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
builder.AddActivity(_settings.FetchAvatarActivityName, _settings.FetchAvatarExecuteAddress);
builder.SetVariables(new
{
context.Message.EmailAddress,
context.Message.StartTime,
context.Message.Duration,
context.Message.RoomCapacity
});
var routingSlip = builder.Build();
await context.Execute(routingSlip);
}
public async Task Execute(ConsumeContext <IOffice365HardDeleteUserCommand> context)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
var command = context.Message;
builder.AddActivity(Office365ServiceConstants.ActivityHardDeleteDatabaseUser,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IDeleteDatabaseUserActivity)),
new
{
command.UserPrincipalName,
WorkflowActivityType = WorkflowActivityType.Office365HardDeleteUser,
WorkflowStep = WorkflowActivityStep.Office365HardDeleteDatabaseUser
});
builder.AddActivity(Office365ServiceConstants.ActivityHardDeletePartnerPlatformUser,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IHardDeletePartnerPlatformUserActivity)),
new
{
command.Office365CustomerId,
command.UserPrincipalName,
WorkflowActivityType = WorkflowActivityType.Office365HardDeleteUser,
WorkflowStep = WorkflowActivityStep.Office365HardDeletePartnerPortalUser
});
builder.AddSubscription(Office365ServiceConstants.QueueOffice365RoutingSlipEventUri,
RoutingSlipEvents.Completed |
RoutingSlipEvents.Faulted |
RoutingSlipEvents.ActivityCompleted |
RoutingSlipEvents.ActivityFaulted |
RoutingSlipEvents.ActivityCompensated |
RoutingSlipEvents.ActivityCompensationFailed);
var routingSlip = builder.Build();
await context.Send <IRoutingSlipStarted>(Office365ServiceConstants.QueueOffice365RoutingSlipStartedUri, new
{
builder.TrackingNumber,
CreateTimestamp = DateTime.UtcNow,
Arguments = context.Message,
WorkflowActivityType = WorkflowActivityType.Office365HardDeleteUser.ToString()
});
await context.Execute(routingSlip);
}
public async Task Execute(ConsumeContext <IOffice365UserChangeLicenseCommand> context)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
var command = context.Message;
builder.AddActivity(Office365ServiceConstants.ActivityRemoveLicensePartnerPortalUser,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IRemoveLicensePartnerPortalUserActivity)),
_mapper.MapRemoveLicensePartnerPortalUserArguments(command));
builder.AddActivity(Office365ServiceConstants.ActivityRemoveLicenseDatabaseUser,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IRemoveLicenseDatabaseUserActivity)),
_mapper.MapRemoveLicenseDatabaseUserArguments(command));
builder.AddActivity(Office365ServiceConstants.ActivityAssignLicenseOffice365PartnerPlatformUser,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IAssignLicenseToPartnerPlatformUserActivity)),
_mapper.MapAssignLicenseOffice365PartnerPlatformUserArguments(command));
builder.AddActivity(Office365ServiceConstants.ActivityAssignLicenseOffice365DatabaseUser,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IAssignLicenseToDatabaseUserActivity)),
_mapper.MapAssignLicenseOffice365DatabaseUserArguments(command));
if (command.UserRoles.Any())
{
builder.AddActivity(Office365ServiceConstants.ActivityGetUserRoles,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IGetUserRolesActivity)), _mapper.MapGetUserRolesArguments(command));
builder.AddActivity(Office365ServiceConstants.ActivityRemoveUserRoles,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IRemoveUserRolesActivity)), _mapper.MapRemoveUserRolesArguments(command));
builder.AddActivity(Office365ServiceConstants.ActivityAssignUserRoles,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IAssignUserRolesActivity)), _mapper.MapAssignUserRolesArguments(command));
}
builder.AddSubscription(Office365ServiceConstants.RoutingSlipEventObserverUri,
RoutingSlipEvents.ActivityCompleted |
RoutingSlipEvents.ActivityFaulted |
RoutingSlipEvents.ActivityCompensated |
RoutingSlipEvents.ActivityCompensationFailed);
var routingSlip = builder.Build();
await context.Execute(routingSlip);
}
public async Task Execute(ConsumeContext <IOffice365UserChangeRolesCommand> context)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
var command = context.Message;
builder.AddActivity(Office365ServiceConstants.ActivityGetUserRoles,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IGetUserRolesActivity)),
_mapper.MapGetUserRolesArguments(command));
builder.AddActivity(Office365ServiceConstants.ActivityRemoveUserRoles,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IRemoveUserRolesActivity)),
_mapper.MapRemoveUserRolesArguments(command));
builder.AddActivity(Office365ServiceConstants.ActivityAssignUserRoles,
_activityConfigurator.GetActivityExecuteUri(context, typeof(IAssignUserRolesActivity)),
_mapper.MapAssignUserRolesArguments(command));
builder.AddVariable("userPrincipalName", context.Message.UserPrincipalName);
builder.AddVariable("workflowActivityType", WorkflowActivityType.Office365UserChangeRoles.ToString());
builder.AddSubscription(Office365ServiceConstants.QueueOffice365RoutingSlipEventUri,
RoutingSlipEvents.Completed |
RoutingSlipEvents.Faulted |
RoutingSlipEvents.ActivityCompleted |
RoutingSlipEvents.ActivityFaulted |
RoutingSlipEvents.ActivityCompensated |
RoutingSlipEvents.ActivityCompensationFailed);
var routingSlip = builder.Build();
await context.Send <IRoutingSlipStarted>(Office365ServiceConstants.QueueOffice365RoutingSlipStartedUri, new
{
builder.TrackingNumber,
CreateTimestamp = DateTime.UtcNow,
Arguments = context.Message,
WorkflowActivityType = WorkflowActivityType.Office365UserChangeRoles.ToString()
});
await context.Execute(routingSlip);
}
public async Task Consume(ConsumeContext <BookingModel> context)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
builder.AddActivity("BookFlight", new Uri("queue:book-flight_execute"),
new BookFlightArgument
{
Message = context.Message.Flight
});
builder.AddActivity("BookHotel", new Uri("queue:book-hotel_execute"),
new BookHotelArgument
{
Message = context.Message.Hotel
});
//Retry activity has applied in its file
builder.AddActivity("BookCar", new Uri("queue:book-car_execute"),
new BookCarArgument
{
Message = context.Message.Car
});
await builder.AddSubscription(context.SourceAddress,
RoutingSlipEvents.Faulted | RoutingSlipEvents.Supplemental,
RoutingSlipEventContents.None, x => x.Send(new BookingFaulted {
BookingId = context.Message.BookingId
}));
await builder.AddSubscription(context.SourceAddress,
RoutingSlipEvents.Completed | RoutingSlipEvents.Supplemental,
RoutingSlipEventContents.None, x => x.Send(new BookingFinalized {
BookingId = context.Message.BookingId
}));
var routingSlip = builder.Build();
await context.Execute(routingSlip);
}
public async Task Consume(ConsumeContext <FullfillOrder> context)
{
if (context.Message.CustomerNumber.StartsWith("INVALID"))
{
throw new InvalidOperationException("We tried, but customer is invalid");
}
if (context.Message.CustomerNumber.StartsWith("MAYBE"))
{
throw new ApplicationException("We randomly exploded, so bad, much tear.");
}
var builder = new RoutingSlipBuilder(NewId.NextGuid());
builder.AddActivity("AllocateInventory",
new Uri("queue:allocate-inventory_execute"), new
{
ItemNumber = "ITEM123",
Quantity = 10.0m
});
builder.AddActivity("PaymentActivity",
new Uri("queue:payment_execute"), new
{
CardNumber = context.Message.PaymentCardNumber ?? "5999-1234-1234-1234",
Amount = 99.95m
});
await builder.AddSubscription(context.SourceAddress,
RoutingSlipEvents.Faulted | RoutingSlipEvents.Supplemental,
RoutingSlipEventContents.None, x => x.Send <OrderFulFillmentFaulted>(new { context.Message.OrderId }));
await builder.AddSubscription(context.SourceAddress,
RoutingSlipEvents.Completed | RoutingSlipEvents.Supplemental,
RoutingSlipEventContents.None, x => x.Send <OrderFulFillmentCompleted>(new { context.Message.OrderId }));
builder.AddVariable("orderId", context.Message.OrderId);
var routingSlip = builder.Build();
await context.Execute(routingSlip);
}
public async Task Consume(ConsumeContext <IFulfillVacationBooking> context)
{
this._logger.LogInformation($"{nameof(FulfillVacationBookingConsumer)} building & executing Routing Slip" +
$"\r\nPayload: {context.Message}");
var builder = new RoutingSlipBuilder(NewId.NextGuid());
builder.AddActivity("BookHotel",
new Uri("queue:book-hotel_execute"), context.Message.FlightBookingInformation);
builder.AddActivity("BookFlight",
new Uri("queue:book-flight_execute"), context.Message.HotelBookingInformation);
if (context.Message.VacationExtras.CarRental != null)
{
builder.AddActivity("RentCar",
new Uri("queue:rent-car_execute"), context.Message.VacationExtras.CarRental);
}
await builder.AddSubscription(context.SourceAddress,
RoutingSlipEvents.Completed | RoutingSlipEvents.Supplemental, RoutingSlipEventContents.None,
x => x.Send <IVacationBookingFulfillmentCompleted>(new
{
context.Message.VacationId,
Timestamp = DateTime.UtcNow
}));
await builder.AddSubscription(context.SourceAddress,
RoutingSlipEvents.Faulted | RoutingSlipEvents.Supplemental, RoutingSlipEventContents.None,
x => x.Send <IVacationBookingFulfillmentFailed>(new
{
context.Message.VacationId,
Reason = "Some reason"
}));
var routingSlip = builder.Build();
await context.Execute(routingSlip);
}
public Task Consume(ConsumeContext <OrderSubmitted> context)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
builder.AddActivity(this.activitiesConfig.ReserveProduct.ActivityName,
this.activitiesConfig.ReserveProduct.ExecuteEndpointUri,
new
{
context.Message.Quantity,
context.Message.ProductName
});
if (!string.IsNullOrWhiteSpace(context.Message.CouponCode))
{
builder.AddActivity(this.activitiesConfig.ApplyCoupon.ActivityName,
this.activitiesConfig.ApplyCoupon.ExecuteEndpointUri,
new { context.Message.CouponCode, context.Message.Quantity });
}
builder.AddActivity(this.activitiesConfig.ProcessPayment.ActivityName,
this.activitiesConfig.ProcessPayment.ExecuteEndpointUri);
builder.AddVariable(nameof(OrderSubmitted.OrderId), context.Message.OrderId);
builder.AddSubscription(new Uri("rabbitmq://localhost/orders"),
RoutingSlipEvents.Completed,
sendEndpoint => sendEndpoint.Send(new OrderProcessingCompleted
{
OrderId = context.Message.OrderId
}));
builder.AddSubscription(new Uri("rabbitmq://localhost/orders"),
RoutingSlipEvents.Faulted);
RoutingSlip routingSlip = builder.Build();
return(context.Execute(routingSlip));
}
public async Task Consume(ConsumeContext <SubmitOrder> context)
{
LogContext.Info?.Log("Submitting Order: {OrderId}", context.Message.OrderId);
var builder = new RoutingSlipBuilder(NewId.NextGuid());
var processEndpoint =
new Uri($"queue:{_endpointNameFormatter.ExecuteActivity<ProcessOrderActivity, ProcessOrderArguments>()}");
builder.AddActivity("Process", processEndpoint);
var eventAddress =
new Uri($"queue:{_endpointNameFormatter.Saga<OrderState>()}");
builder.AddActivity("Process", processEndpoint);
await builder.AddSubscription(eventAddress, RoutingSlipEvents.Completed, endpoint =>
endpoint.Send <OrderProcessed>(context.Message));
await context.Execute(builder.Build());
await context.Publish <OrderSubmitted>(context.Message, x => x.ResponseAddress = context.ResponseAddress);
}
public async Task Consume(ConsumeContext <FulfillOrder> context)
{
if (false)
{
throw new InvalidOperationException("We tried, but the customer is invalid");
}
var builder = new RoutingSlipBuilder(NewId.NextGuid());
//AllocateInventoryActivity
builder.AddActivity("AllocateInventory", new Uri("queue:allocate-inventory_execute"),
new AllocateInventoryArgument
{
ItemNumber = "Item123",
Quantity = 10.0m
});
builder.AddActivity("PaymentActivity", new Uri("queue:payment_execute"),
new PaymentArgument
{
CardNumber = "4444",
Amount = 10
});
builder.AddVariable("OrderId", context.Message.OrderId);
await builder.AddSubscription(context.SourceAddress, RoutingSlipEvents.Faulted,
RoutingSlipEventContents.None, x => x.Send <OrderFulfilmentFaulted>(
new OrderFulfilmentFaulted
{
OrderId = context.Message.OrderId,
}));
var routingSlip = builder.Build();
await context.Execute(routingSlip);
}
public async Task BookMeeting(ConsumeContext<BookMeeting> context)
{
var builder = new RoutingSlipBuilder(NewId.NextGuid());
builder.AddActivity(_settings.ReserveRoomActivityName,
_settings.ReserveRoomExecuteAddress, new
{
ReservationApiKey = "secret"
});
builder.AddActivity(_settings.FetchAvatarActivityName, _settings.FetchAvatarExecuteAddress);
builder.SetVariables(new
{
context.Message.EmailAddress,
context.Message.StartTime,
context.Message.Duration,
context.Message.RoomCapacity
});
var routingSlip = builder.Build();
await context.Execute(routingSlip);
}