public void then_dispatch_templates_updated_are_found_using_ef()
{
List <long> templateIds = _insertedTemplates.Select(x => x.DispatchTemplateId).ToList();
List <DispatchTemplateLong> actualList = DbContext.DispatchTemplates
.Where(x => templateIds.Contains(x.DispatchTemplateId))
.OrderBy(x => x.EventSettingsId)
.ThenBy(x => x.DispatchTemplateId)
.ToList();
actualList.Should().NotBeEmpty();
actualList.Count.Should().Be(_insertedTemplates.Count);
INotificationsMapperFactory mapperFactory = Mocker.GetServiceInstance <INotificationsMapperFactory>();
IMapper mapper = mapperFactory.GetMapper();
for (int i = 0; i < _insertedSettings.Count; i++)
{
DispatchTemplateLong actualItem = actualList[i];
DispatchTemplate <long> mappedActualItem = mapper.Map <DispatchTemplate <long> >(actualItem);
DispatchTemplate <long> expectedItem = _insertedTemplates[i];
mappedActualItem.Should().BeEquivalentTo(expectedItem);
}
}
public void then_dispatch_templates_inserted_are_found_using_ef()
{
INotificationsMapperFactory mapperFactory = Mocker.GetServiceInstance <INotificationsMapperFactory>();
IMapper mapper = mapperFactory.GetMapper();
List <DispatchTemplateLong> actual = DbContext.DispatchTemplates
.OrderBy(x => x.EventSettingsId)
.ThenBy(x => x.DispatchTemplateId)
.ToList();
List <DispatchTemplate <long> > expected = _insertedData
.SelectMany(x => x.Templates)
.ToList();
actual.Should().NotBeEmpty();
int expectedCount = _insertedData.Sum(x => x.Templates.Count);
actual.Count.Should().Be(expectedCount);
for (int i = 0; i < _insertedData.Count; i++)
{
DispatchTemplateLong actualItem = actual[i];
DispatchTemplate <long> mappedActualItem = mapper.Map <DispatchTemplate <long> >(actualItem);
DispatchTemplate <long> expectedItem = expected[i];
expectedItem.EventSettingsId = mappedActualItem.EventSettingsId;
expectedItem.DispatchTemplateId = mappedActualItem.DispatchTemplateId;
mappedActualItem.Should().BeEquivalentTo(expectedItem);
}
}
public virtual async Task <DispatchTemplate <TKey> > Select(TKey dispatchTemplatesId)
{
TotalResult <List <DispatchTemplate <TKey> > > allItems = await GetFromCacheOrFetch().ConfigureAwait(false);
DispatchTemplate <TKey> item = allItems.Data.FirstOrDefault(
x => EqualityComparer <TKey> .Default.Equals(x.DispatchTemplateId, dispatchTemplatesId));
return(item);
}
//methods
public virtual bool Execute(SignalWrapper <SignalDispatch <TKey> > item)
{
if (item.Signal.EventSettingsId == null)
{
//SignalDispatch can be provided by ISignalProver without EventSettingsId
return(true);
}
EventSettings <TKey> eventSettings = _eventSettingsQueries.Select(item.Signal.EventSettingsId.Value).Result;
if (eventSettings == null)
{
_logger.LogError(SenderInternalMessages.Common_NoServiceWithKeyFound,
typeof(EventSettings <TKey>), nameof(EventSettings <TKey> .EventSettingsId), item.Signal.EventSettingsId.Value);
_dispatchQueue.ApplyResult(item, ProcessingResult.NoHandlerFound);
return(false);
}
bool shouldConsolidate = ValidateRequiredProperties(item.Signal, eventSettings);
if (!shouldConsolidate)
{
//Continue processing dispatch without consolidation
return(true);
}
ITemplateDataConsolidator consolidator = MatchConsolidator(item.Signal, eventSettings.ConsolidatorId.Value);
if (consolidator == null)
{
_dispatchQueue.ApplyResult(item, ProcessingResult.NoHandlerFound);
return(false);
}
DispatchTemplate <TKey> dispatchTemplate = eventSettings.Templates == null
? null
: eventSettings.Templates.FirstOrDefault(x => EqualityComparer <TKey> .Default.Equals(x.DispatchTemplateId, item.Signal.DispatchTemplateId.Value));
if (dispatchTemplate == null)
{
_logger.LogError(SenderInternalMessages.Common_NoServiceWithKeyFound,
typeof(DispatchTemplate <TKey>), nameof(DispatchTemplate <TKey> .DispatchTemplateId), item.Signal.DispatchTemplateId.Value);
_dispatchQueue.ApplyResult(item, ProcessingResult.NoHandlerFound);
return(false);
}
IEnumerable <TemplateData[]> batches = GetTemplateDataBatches(item, consolidator.BatchSize);
TemplateData consolidatedData = consolidator.Consolidate(batches);
dispatchTemplate.Update(item.Signal, consolidatedData);
item.IsUpdated = true;
item.IsConsolidationCompleted = true;
return(true);
}
protected virtual void Configure(IMapperConfigurationExpression configuration)
{
configuration.CreateMap <SignalBounce <long>, SignalBounceLong>();
configuration.CreateMap <SignalEvent <long>, SignalEventLong>();
configuration.CreateMap <StoredNotification <long>, StoredNotificationLong>();
configuration.CreateMap <SubscriberDeliveryTypeSettings <long>, SubscriberDeliveryTypeSettingsLong>();
configuration.CreateMap <SubscriberCategorySettings <long>, SubscriberCategorySettingsLong>();
configuration.CreateMap <SubscriberTopicSettings <long>, SubscriberTopicSettingsLong>();
configuration.CreateMap <SubscriberScheduleSettings <long>, SubscriberScheduleSettingsLong>();
configuration.CreateMap <EventSettings <long>, EventSettingsLong>();
configuration.CreateMap <SignalBounceLong, SignalBounce <long> >();
configuration.CreateMap <SignalEventLong, SignalEvent <long> >();
configuration.CreateMap <StoredNotificationLong, StoredNotification <long> >();
configuration.CreateMap <SubscriberDeliveryTypeSettingsLong, SubscriberDeliveryTypeSettings <long> >();
configuration.CreateMap <SubscriberCategorySettingsLong, SubscriberCategorySettings <long> >();
configuration.CreateMap <SubscriberTopicSettingsLong, SubscriberTopicSettings <long> >();
configuration.CreateMap <SubscriberScheduleSettingsLong, SubscriberScheduleSettings <long> >();
configuration.CreateMap <EventSettingsLong, EventSettings <long> >();
//Dispatch template
configuration.CreateMap <DispatchTemplate <long>, DispatchTemplateLong>()
.ForMember(d => d.DerivedEntityData, o => o.MapFrom <ToJsonValueResolver <DispatchTemplate <long>, DispatchTemplateLong> >());
configuration.CreateMap <DispatchTemplateLong, DispatchTemplate <long> >()
.ConstructUsing((serialized, generic) =>
{
DispatchTemplate <long> derivedInstance = (DispatchTemplate <long>)JsonConvert.DeserializeObject(
serialized.DerivedEntityData, new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Objects
});
return(derivedInstance);
});
//Dispatch
configuration.CreateMap <SignalDispatch <long>, SignalDispatchLong>()
.ForMember(d => d.DerivedEntityData, o => o.MapFrom <ToJsonValueResolver <SignalDispatch <long>, SignalDispatchLong> >());
configuration.CreateMap <SignalDispatchLong, SignalDispatch <long> >()
.ConstructUsing((serialized, generic) =>
{
SignalDispatch <long> derivedInstance = (SignalDispatch <long>)JsonConvert.DeserializeObject(
serialized.DerivedEntityData, new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Objects
});
return(derivedInstance);
});
}
public virtual async Task <DispatchTemplate <long> > Select(long dispatchTemplatesId)
{
DispatchTemplateLong item = null;
using (SenderDbContext context = _dbContextFactory.GetDbContext())
{
item = await context.DispatchTemplates
.FirstOrDefaultAsync(x => x.DispatchTemplateId == dispatchTemplatesId)
.ConfigureAwait(false);
}
DispatchTemplate <long> mappedItem = item == null
? null
: _mapper.Map <DispatchTemplate <long> >(item);
return(mappedItem);
}
public async Task <DispatchTemplate <ObjectId> > Select(ObjectId dispatchTemplatesId)
{
var filter = Builders <DispatchTemplate <ObjectId> > .Filter
.Where(p => p.DispatchTemplateId == dispatchTemplatesId);
var options = new FindOptions()
{
AllowPartialResults = false
};
DispatchTemplate <ObjectId> dispatchTemplate = await _collectionFactory
.GetCollection <DispatchTemplate <ObjectId> >()
.Find(filter, options)
.FirstOrDefaultAsync()
.ConfigureAwait(false);
return(dispatchTemplate);
}
protected virtual List <SignalDispatch <TKey> > BuildTemplate(EventSettings <TKey> settings, SignalEvent <TKey> signalEvent
, DispatchTemplate <TKey> template, List <Subscriber <TKey> > subscribers, List <TemplateData> templateData)
{
return(template.Build(settings, signalEvent, subscribers, templateData));
}
