public SubscriptionService(
IEventSubscriptionRepository subscriptionRepository,
INotificationHandler notificationHandler)
{
_subscriptionRepository = subscriptionRepository;
_notification = notificationHandler;
}
/// <summary>
/// Initializes an instance of <see cref="EventSubscriptionManager"/>
/// </summary>
/// <param name="repository">A <see cref="IEventSubscriptionRepository"/> that will be used to maintain subscriptions from a datasource</param>
/// <param name="typeDiscoverer">A <see cref="ITypeDiscoverer"/> for discovering <see cref="IEventSubscriber"/>s in current process</param>
/// <param name="container">A <see cref="IContainer"/> for creating instances of objects/services</param>
public EventSubscriptionManager(IEventSubscriptionRepository repository, ITypeDiscoverer typeDiscoverer, IContainer container)
{
_repository = repository;
_typeDiscoverer = typeDiscoverer;
_container = container;
Initialize();
}
public EventAt15MinutesNotifier(
IEventSubscriptionRepository eventSubscriptionRepository,
IEnumerable <INotificationService> notificationServices,
ILogger <EventAt15MinutesNotifier> logger)
{
_eventSubscriptionRepository = eventSubscriptionRepository;
_notificationServices = notificationServices;
_logger = logger;
}
public SubscribeController(
ISubscriptionService subscriptionService,
IEventSubscriptionRepository repository,
ITnfSession session)
{
_subscriptionService = subscriptionService;
_repository = repository;
_session = session;
}
public EventSubscriptionManager(EventAggregator aggregator)
{
Check.NotNull(aggregator, nameof(aggregator));
_subscriptions = new List <IEventSubscription>();
IEventSubscriptionRepository repository = aggregator;
repository.AddSubscriptionStore(this);
}
void IEvent <TArgs> .Publish(
IEventSubscriptionRepository allSubscriptions,
TArgs payload
)
{
var publication = new EventPublication(this, payload);
foreach (TTarget node in GetHierarchyNodes(payload.Target))
{
PublishToSingleNode(allSubscriptions, node, publication);
}
}
public EventLiveStreamerService(IEventChannelRepository eventChannelRepository,
IEventSubscriptionRepository eventSubscriptionRepository,
IEventRepository eventMessageRepository, ILoggerFactory loggerFactory,
DiagnosticSource diagnosticSource)
{
_diagnosticSource = diagnosticSource;
_eventChannelRepository = new EventChannelService(eventChannelRepository);
_eventSubscriptionService = new EventSubscriptionService(eventSubscriptionRepository);
_eventMessageService = new EventMessageService(eventMessageRepository);
_logger = loggerFactory.CreateLogger <EventLiveStreamerService>();
}
void IEvent <TPayload> .Publish(IEventSubscriptionRepository allSubscriptions, TPayload payload)
{
var publication = new EventPublication(this, payload);
IEnumerable <IEventSubscription> matching = allSubscriptions
.GetSubscriptions(publication)
.OrderBy(x => x.ExecutionOrder);
foreach (var subscription in matching)
{
subscription.Invoke(publication);
}
}
private void PublishToSingleNode(
IEventSubscriptionRepository allSubscriptions,
TTarget node,
EventPublication publication
)
{
IEnumerable <IEventSubscription> matching = allSubscriptions
.GetSubscriptions(publication)
.OfType <IHierarchicalEventSubscription <TTarget> >()
.Where(s => Object.ReferenceEquals(s.Target, node))
.OrderBy(x => x.ExecutionOrder);
foreach (var subscription in matching)
{
subscription.Invoke(publication);
}
}
public SubscriberClientService(IEventChannelRepository eventChannelRepository,
IEventSubscriptionRepository eventSubscriptionRepository,
IEventRepository eventRepository, IOptions <NotificationServiceSettings> settings,
ILoggerFactory loggerFactory, DiagnosticSource diagnosticSource)
{
_logger = loggerFactory.CreateLogger <SubscriberClientService>();
_settings = settings.Value;
_eventLiveStreamer = new EventLiveStreamerService(eventChannelRepository, eventSubscriptionRepository, eventRepository, loggerFactory, diagnosticSource);
_channelName = $"{_settings.ApplicationName}.{_settings.ServiceName}";
var getChannelResult = _eventLiveStreamer.GetChannel(_channelName).Result;
if (!getChannelResult.IsSuccessful || getChannelResult.Result == null)
{
_eventLiveStreamer.CreateChannel(_channelName, _settings.IsFifo, _settings.MaxLifeTimeSubscriber, _settings.MaxLifeTimeMessage).Wait();
}
}
public EventProcessingConfigurationRepository(
ISubscriberRepository subscriberRepository,
ISubscriberContractRepository subscriberContractRepository,
IEventSubscriptionRepository eventSubscriptionRepository,
IEventSubscriptionAddressRepository eventSubscriptionAddressRepository,
IEventHandlerRepository eventHandlerRepository,
IParameterConditionRepository parameterConditionRepository,
IEventSubscriptionStateRepository eventSubscriptionStateRepository,
IContractQueryRepository contractQueryRepository,
IContractQueryParameterRepository contractQueryParameterRepository,
IEventAggregatorRepository eventAggregatorRepository,
ISubscriberQueueRepository subscriberQueueRepository,
ISubscriberSearchIndexRepository subscriberSearchIndexRepository,
IEventHandlerHistoryRepository eventHandlerHistoryRepository,
IEventRuleRepository eventRuleRepository,
ISubscriberStorageRepository subscriberStorageRepository
)
{
Subscribers = subscriberRepository;
SubscriberContracts = subscriberContractRepository;
EventSubscriptions = eventSubscriptionRepository;
EventSubscriptionAddresses = eventSubscriptionAddressRepository;
EventHandlers = eventHandlerRepository;
ParameterConditions = parameterConditionRepository;
EventSubscriptionStates = eventSubscriptionStateRepository;
ContractQueries = contractQueryRepository;
ContractQueryParameters = contractQueryParameterRepository;
EventAggregators = eventAggregatorRepository;
SubscriberQueues = subscriberQueueRepository;
SubscriberSearchIndexes = subscriberSearchIndexRepository;
EventHandlerHistoryRepo = eventHandlerHistoryRepository;
EventRules = eventRuleRepository;
SubscriberStorage = subscriberStorageRepository;
EventContractQueries = new EventContractQueryConfigurationRepository(ContractQueries, SubscriberContracts, ContractQueryParameters);
}
public EventSubscriptionService(IEventSubscriptionRepository repository)
{
Repository = repository;
}
public TalkBackEventTriggerProvider(IEventSubscriptionRepository eventSubscriptionRepository)
{
this.eventSubscriptionRepository = eventSubscriptionRepository;
}
