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)); }