public void EnsureImAbleToAddAndRetrieveSubscriptions() { var subscriptionManager = new SubscriptionManager(); var subscriptions = new List <ISubscription>() { subscriptionManager.AddSubscription <EventOne>(), subscriptionManager.AddSubscription <EventTwo>(), subscriptionManager.AddSubscription <EventThree>(), new Subscription <Event>() }; Assert.IsTrue(subscriptions.Contains(subscriptionManager.FindSubscription <EventOne>())); Assert.IsTrue(subscriptions.Contains(subscriptionManager.FindSubscription <EventTwo>())); Assert.IsTrue(subscriptions.Contains(subscriptionManager.FindSubscription <EventThree>())); Assert.IsFalse(subscriptions.Contains(subscriptionManager.FindSubscription <Event>())); }
public Task <ResponseBase> Handle(HttpInformation context, SubscribeCommand command, ExecutionContext executionContext) { if (databaseOptions.DisableIncludePrefilter && command.Prefilters.Any(p => p is IncludePrefilter)) { throw new IncludeNotAllowedException(command.ContextName, command.CollectionName); } if (databaseOptions.DisableSelectPrefilter && command.Prefilters.Any(p => p is SelectPrefilter)) { throw new SelectNotAllowedException(command.ContextName, command.CollectionName); } SapphireDbContext db = GetContext(command.ContextName); KeyValuePair <Type, string> property = CollectionHelper.GetCollectionType(db, command); if (property.Key.GetModelAttributesInfo().DisableQueryAttribute != null) { throw new OperationDisabledException("Query", command.ContextName, command.CollectionName); } command.Prefilters.ForEach(prefilter => prefilter.Initialize(property.Key)); ResponseBase response = CollectionHelper.GetCollection(db, command, property, command.Prefilters, context, serviceProvider); subscriptionManager.AddSubscription(command.ContextName, command.CollectionName, command.Prefilters, Connection, command.ReferenceId); return(Task.FromResult(response)); }
public void SuccessfulyAddNewSubsription() { var subsriptionManager = new SubscriptionManager(); subsriptionManager.AddSubscription(Mock.Of <IChannel>(), new [] { "topic" }); Assert.IsTrue(true); }
public void ReturnChannelsByTopic() { var subsriptionManager = new SubscriptionManager(); var ch1 = new Mock <IChannel>(); ch1.Setup(c => c.IsOpened).Returns(true); subsriptionManager.AddSubscription(ch1.Object, new[] { "topic1", "topic2" }); subsriptionManager.AddSubscription(Mock.Of <IChannel>(), new[] { "topic1" }); subsriptionManager.AddSubscription(Mock.Of <IChannel>(), new[] { "topic3" }); var channels = subsriptionManager.GetChannelsByTopic("topic1"); Assert.AreEqual(1, channels.Length); Assert.AreEqual(ch1.Object, channels[0]); }
public void Any_Empty_True() { // Arrange var subscription = new SubscriptionManager(); subscription.AddSubscription <UserCreatedEvent, UserEventHandler>(); // Act & Assert Assert.True(subscription.Any()); }
public void SubscriptionAddTest() { var subscription = new Subscription() { SubscriptionId = Guid.NewGuid(), StartDate = DateTime.Now, EndDate = DateTime.Now.AddDays(90), Price = 1000 }; _subManager.AddSubscription(subscription); }
public Task<ResponseBase> Handle(HttpInformation context, SubscribeCommand command) { ResponseBase response = CollectionHelper.GetCollection(GetContext(command.ContextName), command, context, serviceProvider); if (response.Error == null) { subscriptionManager.AddSubscription(command.ContextName, command.CollectionName, command.Prefilters, Connection, command.ReferenceId); } return Task.FromResult(response); }
public void Subscribe <TMessage, THandler>() where TMessage : BusMessage where THandler : IMessageHandler <TMessage> { var routingKey = GetRoutingKey <TMessage>(); // add subscription _subscriptionManager.AddSubscription(routingKey, typeof(TMessage), typeof(THandler)); // start consume StartConsuming(routingKey); }
/// <summary> 订阅消息 </summary> /// <typeparam name="T"></typeparam> /// <typeparam name="TH"></typeparam> /// <param name="handler"></param> /// <param name="option"></param> /// <returns></returns> public override Task Subscribe <T, TH>(Func <TH> handler, SubscribeOption option = null) { _consumerChannel = _consumerChannel ?? CreateConsumerChannel(); var opt = (option ?? GetSubscription(typeof(TH))) as RabbitMqSubscribeOption ?? new RabbitMqSubscribeOption(); if (opt.PrefetchCount > 0) { //同时只能接受1条消息 _consumerChannel.BasicQos(0, (ushort)opt.PrefetchCount, false); } var queue = opt.Queue; var dataType = typeof(T); string key; if (typeof(DEvent).IsAssignableFrom(dataType)) { key = !string.IsNullOrWhiteSpace(opt.RouteKey) ? opt.RouteKey : typeof(T).GetRouteKey(); } else { key = string.IsNullOrWhiteSpace(opt.RouteKey) ? opt.Queue : opt.RouteKey; } DeclareAndBindQueue(queue, key, opt); if (!_connection.IsConnected) { _connection.TryConnect(); } var consumer = new EventingBasicConsumer(_consumerChannel); consumer.Received += async(model, ea) => { try { await ReceiveMessage(queue, ea, opt); } catch (Exception ex) { _logger.LogError(ex, $"MQ订阅处理异常:{ex.Message}"); } }; _consumerChannel.BasicConsume(queue, false, consumer); SubscriptionManager.AddSubscription <T, TH>(handler, queue); return(Task.CompletedTask); }
public void AddSubscription_EventHasNotSubscription_HandlerNotEmpty() { // Arrange var subscription = new SubscriptionManager(); // Act subscription.AddSubscription <UserCreatedEvent, UserEventHandler>(); // Assert var subscriptionEvent = subscription.FindSubscription <UserCreatedEvent, UserEventHandler>(); Assert.NotNull(subscriptionEvent); }
public void Clear_Subscriptions_Empty() { // Arrange var subscription = new SubscriptionManager(); subscription.AddSubscription <UserCreatedEvent, UserEventHandler>(); // Act subscription.Clear(); // Assert Assert.False(subscription.Any()); }
public void GetHandlers_EventRegistered_EventHandlers() { // Arrange var subscription = new SubscriptionManager(); subscription.AddSubscription <UserCreatedEvent, UserEventHandler>(); // Act var handlers = subscription.GetHandlers <UserCreatedEvent>(); // Assert Assert.Contains(handlers, handler => handler.EventHandlerType == typeof(UserEventHandler)); }
public void HasSubscriptionsForEvent_EventRegistered_True() { // Arrange var subscription = new SubscriptionManager(); subscription.AddSubscription <UserCreatedEvent, UserEventHandler>(); // Act var hasSubscription = subscription.HasSubscriptionsForEvent <UserCreatedEvent>(); // Assert Assert.True(hasSubscription); }
public void RemoveSubscription_EventRegistered_NotRemove() { // Arrange var subscription = new SubscriptionManager(); subscription.AddSubscription <UserCreatedEvent, UserEventHandler>(); // Act subscription.RemoveSubscription <UserCreatedEvent, UserEventHandler>(); // Assert Assert.False(subscription.Any()); }
public Task <ResponseBase> Handle(HttpInformation context, SubscribeQueryCommand queryCommand, ExecutionContext executionContext) { SapphireDbContext db = GetContext(queryCommand.ContextName); KeyValuePair <Type, string> property = CollectionHelper.GetCollectionType(db, queryCommand); List <IPrefilterBase> prefilters = CollectionHelper.GetQueryPrefilters(property, queryCommand, Connection.Information, serviceProvider); ResponseBase response = CollectionHelper.GetCollection(db, queryCommand, property, prefilters, context, serviceProvider); subscriptionManager.AddSubscription(queryCommand.ContextName, queryCommand.CollectionName, prefilters, Connection, queryCommand.ReferenceId); return(Task.FromResult(response)); }
public void FindSubscription_EventHasSubscription_Subscription() { // Arrange var subscription = new SubscriptionManager(); subscription.AddSubscription <UserCreatedEvent, UserEventHandler>(); // Act var subscriptionEvent = subscription.FindSubscription <UserCreatedEvent, UserEventHandler>(); // Assert Assert.NotNull(subscriptionEvent); Assert.Equal(typeof(UserCreatedEvent), subscriptionEvent.EventType); Assert.Equal(typeof(UserEventHandler), subscriptionEvent.EventHandlerType); Assert.Equal(typeof(UserCreatedEvent).Name, subscriptionEvent.EventName); }
public void AddSubscription_EventHasSubscription_EventHandlerAlreadyRegisteredException() { // Arrange var eventType = typeof(UserCreatedEvent); var eventHandlerType = typeof(UserEventHandler); var subscription = new SubscriptionManager(); subscription.AddSubscription <UserCreatedEvent, UserEventHandler>(); // Act & Assert var exception = Assert.Throws <EventHandlerAlreadyRegisteredException <UserCreatedEvent, UserEventHandler> >(() => subscription.AddSubscription <UserCreatedEvent, UserEventHandler>()); // Assert Assert.NotEmpty(exception.Message); Assert.Equal(eventType, exception.EventType); Assert.Equal(eventHandlerType, exception.EventHandlerType); }
public void FindSubscriptions_EventHasSubscription_Subscriptions() { // Arrange var subscription = new SubscriptionManager(); subscription.AddSubscription <UserCreatedEvent, UserEventHandler>(); // Act var subscriptionsEvents = subscription.FindSubscriptions <UserCreatedEvent>(); // Assert Assert.NotEmpty(subscriptionsEvents); Assert.Contains(subscriptionsEvents, x => x.EventType == typeof(UserCreatedEvent) && x.EventHandlerType == typeof(UserEventHandler) && x.EventName == typeof(UserCreatedEvent).Name ); }
public void Subscribe <TEvent, TEventHandler>() where TEvent : Event where TEventHandler : IEventHandler <TEvent> { _subscriptionManager.AddSubscription <TEvent, TEventHandler>(); }
public CampaignStockCheckHandler(IRepository <Sale> saleRepository, IRepository <Campaign> campaignRepository, SubscriptionManager subscriptionManager) { _saleRepository = saleRepository; _campaignRepository = campaignRepository; subscriptionManager.AddSubscription <NewProductOrderCreatedEvent, CampaignStockCheckHandler>(); }
public NewOrderCreatedEventHandler(IRepository <Sale> saleRepository, IRepository <Product> productRepository, SubscriptionManager subscriptionManager) { _saleRepository = saleRepository; _productRepository = productRepository; subscriptionManager.AddSubscription <NewProductOrderCreatedEvent, NewOrderCreatedEventHandler>(); }
public async Task <TaskModuleContinueResponse> OnTeamsTaskModuleSubmitAsync(ITurnContext context, CancellationToken cancellationToken) { var state = await _stateAccessor.GetAsync(context, () => new SkillState()); var activityValueObject = JObject.FromObject(context.Activity.Value); var isDataObject = activityValueObject.TryGetValue("data", StringComparison.InvariantCultureIgnoreCase, out JToken dataValue); JObject dataObject = null; if (isDataObject) { dataObject = dataValue as JObject; // Get filterUrgency var filterUrgency = dataObject.GetValue("UrgencyFilter"); // Get filterName var filterName = dataObject.GetValue("FilterName"); //// Get NotificationNamespace name var notificationNameSpace = dataObject.GetValue("NotificationNameSpace"); //// Get filterName var postNotificationAPIName = dataObject.GetValue("PostNotificationAPIName"); // Check if this BusinessRule is already created if not create proactivesubscription var isNewSubscription = await _subscriptionManager.AddSubscription(context, filterName.Value <string>(), context.Activity.GetConversationReference(), cancellationToken); // Create Managemenet object if (isNewSubscription) { var management = _serviceManager.CreateManagementForSubscription(_settings, state.AccessTokenResponse, state.ServiceCache); // Create Subscription New RESTAPI for callback from ServiceNow var response = await management.CreateNewRestMessage(notificationNameSpace.Value <string>(), postNotificationAPIName.Value <string>()); // Create Subscription BusinessRule var result = await management.CreateSubscriptionBusinessRule(filterUrgency.Value <string>(), filterName.Value <string>(), notificationNameSpace.Value <string>(), postNotificationAPIName.Value <string>()); if (result == System.Net.HttpStatusCode.OK) { var serviceNowSub = new ServiceNowSubscription { FilterName = filterName.Value <string>(), FilterCondition = "UrgencyChanges, DescriptionChanges, PriorityChanges, AssignedToChanges", NotificationNameSpace = notificationNameSpace.Value <string>(), NotificationApiName = postNotificationAPIName.Value <string>(), }; ActivityReferenceMap activityReferenceMap = await _activityReferenceMapAccessor.GetAsync( context, () => new ActivityReferenceMap(), cancellationToken) .ConfigureAwait(false); // Return Added Incident Envelope // Get saved Activity Reference mapping to conversation Id activityReferenceMap.TryGetValue(context.Activity.Conversation.Id, out var activityReference); // Update Create Ticket Button with another Adaptive card to Update/Delete Ticket await _teamsTicketUpdateActivity.UpdateTaskModuleActivityAsync( context, activityReference, SubscriptionTaskModuleAdaptiveCard.BuildSubscriptionCard(serviceNowSub, _settings.MicrosoftAppId), cancellationToken); } } // Create ProactiveModel // Get Conversation from Activity var conversation = context.Activity.GetConversationReference(); // ProactiveConversationReferenceMap to save list of conversation var proactiveConversationReferenceMap = await _proactiveStateConversationReferenceMapAccessor.GetAsync( context, () => new ConversationReferenceMap(), cancellationToken) .ConfigureAwait(false); // Get Conversations from map proactiveConversationReferenceMap.TryGetValue(filterName.Value <string>(), out var listOfConversationReferences); if (listOfConversationReferences == null) { proactiveConversationReferenceMap[filterName.Value <string>()] = new List <ConversationReference> { conversation }; } else if (!listOfConversationReferences.Contains(conversation)) { listOfConversationReferences.Add(conversation); proactiveConversationReferenceMap[filterName.Value <string>()] = listOfConversationReferences; } // Save ActivityReference and ProactiveState Accessor await _proactiveStateConversationReferenceMapAccessor.SetAsync(context, proactiveConversationReferenceMap).ConfigureAwait(false); // Save Conversation State await _proactiveState.SaveChangesAsync(context, false, cancellationToken); await _conversationState.SaveChangesAsync(context, false, cancellationToken); return(new TaskModuleContinueResponse() { Value = new TaskModuleTaskInfo() { Title = "Subscription", Height = "medium", Width = 500, Card = new Attachment { ContentType = AdaptiveCard.ContentType, Content = SubscriptionTaskModuleAdaptiveCard.SubscriptionResponseCard($"Created Subscription With Business RuleName: {filterName} in ServiceNow") } } }); } return(new TaskModuleContinueResponse() { Value = new TaskModuleTaskInfo() { Title = "Subscription", Height = "medium", Width = 500, Card = new Attachment { ContentType = AdaptiveCard.ContentType, Content = SubscriptionTaskModuleAdaptiveCard.SubscriptionResponseCard("Failed To Create Subscription") } } }); }
public CampaignProductUpdateHandler(IRepository <Product> productRepository, IRepository <Campaign> campaignRepository, SubscriptionManager subscriptionManager) { _productRepository = productRepository; _campaignRepository = campaignRepository; subscriptionManager.AddSubscription <UpdateCampaignCurrentManipulationEvent, CampaignProductUpdateHandler>(); }
public CampaignDeactivedEventHandler(IRepository <Product> productRepository, SubscriptionManager subscriptionManager) { _productRepository = productRepository; subscriptionManager.AddSubscription <CampaignDeactivedEvent, CampaignDeactivedEventHandler>(); }
public SubscriptionToken Subscribe <TEvent, THandler>() where TEvent : IntegrationEvent where THandler : IIntegrationEventHandler <TEvent> { return(SubscriptionManager.AddSubscription <TEvent, THandler>()); }
public JsonResult Subscription(string mail) { string proc = SubscriptionManager.AddSubscription(mail); return(Json(proc, JsonRequestBehavior.AllowGet)); }