public PersonsController(ICustomerLogic customerLogic, IProblemCollector problemCollector, IMapper mapper,
IPublishEndpoint publishEndpoint) : base(customerLogic, problemCollector, mapper, publishEndpoint)
{
}
public HeartbeatBackgroundService(ILogger <HeartbeatBackgroundService> logger, IPublishEndpoint publishEndpoint)
{
_logger = logger;
_publishEndpoint = publishEndpoint;
}
public OrderProcessingController(IPublishEndpoint endpoint, ILogger <OrderProcessingController> logger)
{
_endpoint = endpoint;
_logger = logger;
}
public static Task Publish(IPublishEndpoint endpoint, object values, IPipe <PublishContext <TMessage> > pipe, CancellationToken cancellationToken)
{
return(GetInitializer(values.GetType()).Publish(endpoint, values, pipe, cancellationToken));
}
public ProdutorConsumer(IPublishEndpoint publishEndpoint, ILogger <ProdutorConsumer> logger)
{
_publishEndPoint = publishEndpoint;
_logger = logger;
}
public BasketController(IBasketRepository repository, DiscountGrpcService discountGrpcService, IPublishEndpoint publishEndpoint, IMapper mapper)
{
_repository = repository ?? throw new ArgumentNullException(nameof(repository));
_discountGrpcService = discountGrpcService ?? throw new ArgumentNullException(nameof(discountGrpcService));
_publishEndpoint = publishEndpoint ?? throw new ArgumentNullException(nameof(publishEndpoint));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
}
public SubmitController(IPublishEndpoint publishEndpoint, CancelationTokenStore cancelationTokenStore)
{
this.publishEndpoint = publishEndpoint;
this.cancelationTokenStore = cancelationTokenStore;
}
public OutboxPublishEndpoint(OutboxContext outboxContext, IPublishEndpoint publishEndpoint)
{
_outboxContext = outboxContext;
_publishEndpoint = publishEndpoint;
}
public PublishRequestSendEndpoint(IPublishEndpoint endpoint)
{
_endpoint = endpoint;
}
/// <summary>
/// Cancel a scheduled message using the tokenId that was returned when the message was scheduled.
/// </summary>
/// <param name="bus"></param>
/// <param name="tokenId">The tokenId of the scheduled message</param>
public static async Task CancelScheduledMessage(this IPublishEndpoint bus, Guid tokenId)
{
var command = new CancelScheduledMessageCommand(tokenId);
await bus.Publish <CancelScheduledMessage>(command).ConfigureAwait(false);
}
public PublishMessageMassTransitAdaptor(IPublishEndpoint massTransitEndPoint)
{
_massTransitEndPoint = massTransitEndPoint;
}
public IntegrationDeletePublisher(
IPublishEndpoint publishEndpoint
)
{
_publishEndpoint = publishEndpoint;
}
public ClientService(IUnitOfWork uow, IPublishEndpoint publishEndpoint)
{
this._uow = uow;
this._publishEndpoint = publishEndpoint;
}
public OrderManagerService(IPublishEndpoint publishEndpoint)
{
_publishEndpoint = publishEndpoint;
}
public CreateProductConsumer(ILogger <CreateProductConsumer> logger, ApplicationDbContext applicationDbContext, IPublishEndpoint publishEndpoint)
{
_logger = logger;
_applicationDbContext = applicationDbContext;
_publishEndpoint = publishEndpoint;
}
public EventPublisher(IPublishEndpoint publishEndpoint)
{
Guard.ConstructorArgumentIsNotNull(publishEndpoint, nameof(publishEndpoint));
_publishEndpoint = publishEndpoint;
}
public CustomerController(IPublishEndpoint publishEndpoint)
{
_publishEndpoint = publishEndpoint;
}
public ShipmentController(IPublishEndpoint bus)
{
this.bus = bus;
}
public Consumer1(IPublishEndpoint publishEndpointDefault, IBusTwo publishEndpoint,
TaskCompletionSource <ConsumeContext <SimpleMessageInterface> > taskCompletionSource)
{
_publishEndpoint = publishEndpoint;
_taskCompletionSource = taskCompletionSource;
}
public EventHubMessageConsumer(IPublishEndpoint publishEndpoint, TaskCompletionSource <ConsumeContext <EventHubMessage> > taskCompletionSource)
{
_publishEndpoint = publishEndpoint;
_taskCompletionSource = taskCompletionSource;
}
public Consumer2(IPublishEndpoint publishEndpoint, TaskCompletionSource <ConsumeContext <PingMessage> > taskCompletionSource)
{
_taskCompletionSource = taskCompletionSource;
}
public ReadController(IPublishEndpoint publishEndpoint)
{
_publishEndpoint = publishEndpoint;
}
public ProductController(IProductService productService, IPublishEndpoint publishEndpoint)
{
this.productService = productService;
this.publishEndpoint = publishEndpoint;
}
public static Task Publish(IPublishEndpoint endpoint, object values, CancellationToken cancellationToken)
{
return(GetInitializer(values.GetType()).Publish(endpoint, values, cancellationToken));
}
public IdentityMutations(ApplicationDbContext context, IEventService template1EventService, UserManager <ApplicationUser> userManager, JwtService jwtService, SignInManager <ApplicationUser> signInManager, IHttpContextAccessor contextAccessor, IPublishEndpoint publishEndpoint)
{
_context = context ?? throw new ArgumentNullException(nameof(context));;
_eventService = template1EventService ?? throw new ArgumentNullException(nameof(template1EventService));
_userManager = userManager;
_jwtService = jwtService;
_signInManager = signInManager;
}
public EventController(ILogger <EventController> logger, IPublishEndpoint publishEndpoint)
{
_publishEndpoint = publishEndpoint;
_logger = logger;
}
public static async Task PublishAnonymous <T>(this IPublishEndpoint publishEndpoint, Action <T> propertySetter,
CancellationToken cancellationToken = default(CancellationToken))
where T : class
{
await publishEndpoint.Publish(MessageHelper.CreateMessage(propertySetter), cancellationToken);
}
public OrderController(IPublishEndpoint publishEndpoint)
{
_publishEndpoint = publishEndpoint;
}
public ProductsPublisherController(IPublishEndpoint publishEndpoint, IRequestClient <CheckOrderStatus> client)
{
_publishEndpoint = publishEndpoint;
_client = client;
}
public static Task Publish(IPublishEndpoint endpoint, object message, Type messageType, IPipe<PublishContext> pipe,
CancellationToken cancellationToken = default(CancellationToken))
{
return Cached.Converters.Value[messageType].Publish(endpoint, message, pipe, cancellationToken);
}
/// <summary>
/// Schedules a recurring message to be sent to the bus using a Publish, which should only be used when
/// the quartz service is on a single shared queue or behind a distributor
/// </summary>
/// <typeparam name="T">The scheduled message type</typeparam>
/// <param name="publishEndpoint">The bus from which the scheduled message command should be published</param>
/// <param name="destinationAddress">The destination address where the schedule message should be sent</param>
/// <param name="schedule">The recurring schedule instance</param>
/// <param name="message">The message to send</param>
/// <param name="contextCallback">Optional: A callback that gives the caller access to the publish context.</param>
/// <returns>A handled to the scheduled message</returns>
public static async Task <ScheduledRecurringMessage <T> > ScheduleRecurringMessage <T>(this IPublishEndpoint publishEndpoint, Uri destinationAddress,
RecurringSchedule schedule, T message, IPipe <PublishContext <ScheduleRecurringMessage <T> > > contextCallback = null)
where T : class
{
var command = new ScheduleRecurringMessageCommand <T>(schedule, destinationAddress, message);
await publishEndpoint.Publish(command, contextCallback ?? Pipe.Empty <PublishContext <ScheduleRecurringMessage <T> > >()).ConfigureAwait(false);
return(new ScheduledRecurringMessageHandle <T>(command.Schedule, command.Destination, command.Payload));
}
