public virtual async Task <List <SignalDispatch <long> > > SelectLocked(DispatchQueryParameters <long> parameters, Guid lockId, DateTime lockExpirationDate) { List <SignalDispatch <long> > list = null; using (SenderDbContext context = _dbContextFactory.GetDbContext()) { IQueryable <SignalDispatchLong> query = context.SignalDispatches.AsQueryable <SignalDispatchLong>(); query = Filter(query, parameters); query = query.Where(msg => msg.LockedBy == lockId && msg.LockedSinceUtc != null && msg.LockedSinceUtc >= lockExpirationDate); List <SignalDispatchLong> response = await query .OrderBy(msg => msg.SendDateUtc) .Take(parameters.Count) .ToListAsync() .ConfigureAwait(false); list = response .Select(_mapper.Map <SignalDispatch <long> >) .ToList(); } return(list); }
public void then_topic_settings_matched_by_subscriber_id_are_updated_using_ef() { SenderDbContext dbContext = DbContext; List <SubscriberTopicSettingsLong> _matchedSubscribers = dbContext.SubscriberTopicSettings .Where(x => _subscriberIds.Contains(x.SubscriberId)) .ToList(); _matchedSubscribers.Should().NotBeEmpty(); _matchedSubscribers.Count.Should().Be(_subscriberIds.Count); _matchedSubscribers = _matchedSubscribers.OrderBy(x => x.SubscriberId).ToList(); _subscriberIds = _subscriberIds.OrderBy(x => x).ToList(); for (int i = 0; i < _subscriberIds.Count; i++) { SubscriberTopicSettingsLong actualItem = _matchedSubscribers[i]; actualItem.DeliveryType.Should().Be(_deliveryType); actualItem.CategoryId.Should().Be(_categoryId); actualItem.TopicId.Should().Be(_topicId); actualItem.SendCount.Should().Be(1); actualItem.LastSendDateUtc.Should().NotBeNull(); actualItem.LastSendDateUtc.Value.Should().BeCloseTo(_sendDate, 1000); } }
//update public virtual async Task Update(SubscriberDeliveryTypeSettingsLong item) { using (SenderDbContext context = _dbContextFactory.GetDbContext()) { context.SubscriberDeliveryTypeSettings.Attach(item); context.Entry(item).State = EntityState.Modified; int changes = await context.SaveChangesAsync().ConfigureAwait(false); } }
//select public virtual Task <bool> CheckAddressExists(int deliveryType, string address) { bool exist = false; using (SenderDbContext context = _dbContextFactory.GetDbContext()) { exist = context.SubscriberDeliveryTypeSettings.Any( x => x.Address == address && x.DeliveryType == deliveryType); } return(Task.FromResult(exist)); }
public override void SpecInit(INeedDbContext instance) { SenderDbContext context = instance.DbContext; //Disable all foreign keys. context.Database.ExecuteSqlRaw("EXEC sp_msforeachtable \"ALTER TABLE ? NOCHECK CONSTRAINT all\""); //Remove all data from tables EXCEPT for the EF Migration History table! context.Database.ExecuteSqlRaw("EXEC sp_msforeachtable \"SET QUOTED_IDENTIFIER ON; IF '?' != '[dbo].[__MigrationHistory]' DELETE FROM ?\""); //Turn FKs back on context.Database.ExecuteSqlRaw("EXEC sp_msforeachtable \"ALTER TABLE ? WITH CHECK CHECK CONSTRAINT all\""); }
public virtual async Task <EventSettings <long> > Select(long eventSettingsId) { EventSettingsLong eventSettings = null; using (SenderDbContext context = _dbContextFactory.GetDbContext()) { eventSettings = await context.EventSettings .Include(x => x.TemplatesNavigation) .FirstOrDefaultAsync(x => x.EventSettingsId == eventSettingsId) .ConfigureAwait(false); } return(eventSettings); }
public virtual async Task <List <SubscriberDeliveryTypeSettingsLong> > Select(long subscriberId) { List <SubscriberDeliveryTypeSettingsLong> list = null; using (SenderDbContext context = _dbContextFactory.GetDbContext()) { list = await context.SubscriberDeliveryTypeSettings .Where(p => p.SubscriberId == subscriberId) .ToListAsync() .ConfigureAwait(false); } return(list.ToList()); }
//select public virtual async Task <List <SubscriberCategorySettingsLong> > Select(List <long> subscriberIds, int categoryId) { List <SubscriberCategorySettingsLong> list = null; using (SenderDbContext context = _dbContextFactory.GetDbContext()) { list = await context.SubscriberCategorySettings.Where( p => subscriberIds.Contains(p.SubscriberId) && p.CategoryId == categoryId) .ToListAsync() .ConfigureAwait(false); } return(list); }
public virtual async Task <SubscriberDeliveryTypeSettingsLong> Select(long subscriberId, int deliveryType) { SubscriberDeliveryTypeSettingsLong item = null; using (SenderDbContext context = _dbContextFactory.GetDbContext()) { item = await context.SubscriberDeliveryTypeSettings.Where( p => p.SubscriberId == subscriberId && p.DeliveryType == deliveryType) .FirstOrDefaultAsync() .ConfigureAwait(false); } return(item); }
//update public virtual async Task Update(UpdateParameters parameters, List <SignalDispatch <long> > items) { if (!parameters.UpdateAnything) { return; } using (SenderDbContext context = _dbContextFactory.GetDbContext()) { SqlParameter updateSubscribersParam = ToUpdateSubscriberType(items); string command = CreateUpdateQuery(parameters, context); int changes = await context.Database.ExecuteSqlCommandAsync(command, updateSubscribersParam) .ConfigureAwait(false); } }
public virtual async Task <List <SubscriberDeliveryTypeSettingsLong> > Select( int deliveryType, List <string> addresses) { List <SubscriberDeliveryTypeSettingsLong> list = null; using (SenderDbContext context = _dbContextFactory.GetDbContext()) { list = await context.SubscriberDeliveryTypeSettings.Where( p => p.DeliveryType == deliveryType && addresses.Contains(p.Address)) .ToListAsync() .ConfigureAwait(false); } return(list.Cast <SubscriberDeliveryTypeSettingsLong>().ToList()); }
public virtual async Task <List <DispatchTemplate <long> > > SelectForEventSettings(long eventSettingsId) { List <DispatchTemplateLong> items = null; using (SenderDbContext context = _dbContextFactory.GetDbContext()) { items = await context.DispatchTemplates .Where(x => x.EventSettingsId == eventSettingsId) .ToListAsync() .ConfigureAwait(false); } List <DispatchTemplate <long> > mappedItems = items .Select(_mapper.Map <DispatchTemplate <long> >).ToList(); return(mappedItems); }
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 virtual async Task <SubscriberTopicSettingsLong> Select( long subscriberId, int categoryId, string topicId) { SubscriberTopicSettingsLong item = null; using (SenderDbContext context = _dbContextFactory.GetDbContext()) { item = await context.SubscriberTopicSettings.Where( p => p.SubscriberId == subscriberId && p.CategoryId == categoryId && p.TopicId == topicId) .FirstOrDefaultAsync() .ConfigureAwait(false); } return(item); }
private static void InitDatabase(IContainer container) { bool dbExists = false; ISenderDbContextFactory contextFactory = container.Resolve <ISenderDbContextFactory>(); using (SenderDbContext context = contextFactory.GetDbContext()) { var creator = (SqlServerDatabaseCreator)context.Database.GetService <IDatabaseCreator>(); dbExists = creator.Exists(); } if (dbExists) { return; } contextFactory.InitializeDatabase(); var deliveryTypeQueries = container.Resolve <ISubscriberDeliveryTypeSettingsQueries <SubscriberDeliveryTypeSettingsLong, long> >(); deliveryTypeQueries.Insert(new List <SubscriberDeliveryTypeSettingsLong> { new SubscriberDeliveryTypeSettingsLong { SubscriberId = 1, DeliveryType = (int)Model.DeliveryTypes.Email, Address = "*****@*****.**", IsEnabled = true } }).Wait(); var categoryQueries = container.Resolve <ISubscriberCategorySettingsQueries <SubscriberCategorySettings <long>, long> >(); categoryQueries.Insert(new List <SubscriberCategorySettings <long> > { new SubscriberCategorySettings <long> { SubscriberId = 1, DeliveryType = (int)Model.DeliveryTypes.Email, CategoryId = (int)CategoryTypes.CustomerGreetings, IsEnabled = true } }).Wait(); }
public virtual async Task <List <EventSettings <long> > > SelectByKey(int eventKey) { List <EventSettingsLong> eventSettings = null; using (SenderDbContext context = _dbContextFactory.GetDbContext()) { eventSettings = await context.EventSettings .Where(x => x.EventKey == eventKey) .Include(x => x.TemplatesNavigation) .ToListAsync() .ConfigureAwait(false); } List <EventSettings <long> > result = eventSettings .Cast <EventSettings <long> >() .ToList(); return(result); }
//select public virtual async Task <List <SubscriberScheduleSettings <long> > > Select( List <long> subscriberIds, List <int> receivePeriodSets = null) { List <SubscriberScheduleSettingsLong> list = null; using (SenderDbContext context = _dbContextFactory.GetDbContext()) { IQueryable <SubscriberScheduleSettingsLong> query = context.SubscriberScheduleSettings.Where( p => subscriberIds.Contains(p.SubscriberId)); if (receivePeriodSets != null) { query = query.Where(p => receivePeriodSets.Contains(p.Set)); } list = await query.ToListAsync().ConfigureAwait(false); } return(list.Cast <SubscriberScheduleSettings <long> >().ToList()); }
public virtual async Task <List <SignalDispatch <long> > > SelectNotSetLock(DispatchQueryParameters <long> parameters) { List <SignalDispatch <long> > list = null; using (SenderDbContext context = _dbContextFactory.GetDbContext()) { IQueryable <SignalDispatchLong> query = context.SignalDispatches.AsQueryable <SignalDispatchLong>(); query = Filter(query, parameters); List <SignalDispatchLong> response = await query .OrderBy(msg => msg.SendDateUtc) .Take(parameters.Count) .ToListAsync() .ConfigureAwait(false); list = response .Select(_mapper.Map <SignalDispatch <long> >) .ToList(); } return(list); }
public Repository(SenderDbContext senderDbContext) { _senderDbContext = senderDbContext; }
protected virtual IQueryable <SubscriberTopicSettingsLong> CreateTopicSelectQuery( SubscriptionParameters parameters, SubscribersRangeParameters <long> subscribersRange, SenderDbContext context) { IQueryable <SubscriberTopicSettingsLong> query = context.SubscriberTopicSettings .Where(p => p.TopicId == subscribersRange.TopicId && p.CategoryId == parameters.CategoryId.Value && p.IsDeleted == false); if (subscribersRange.FromSubscriberIds != null) { query = query.Where(p => subscribersRange.FromSubscriberIds.Contains(p.SubscriberId)); } if (parameters.DeliveryType != null) { query = query.Where(p => p.DeliveryType == parameters.DeliveryType.Value); } if (subscribersRange.SubscriberIdRangeFromIncludingSelf != null) { query = query.Where(p => subscribersRange.SubscriberIdRangeFromIncludingSelf.Value <= p.SubscriberId); } if (subscribersRange.SubscriberIdRangeToIncludingSelf != null) { query = query.Where(p => p.SubscriberId <= subscribersRange.SubscriberIdRangeToIncludingSelf.Value); } if (parameters.CheckTopicEnabled) { query = query.Where(p => p.IsEnabled == true); } if (parameters.CheckTopicSendCountNotGreater != null) { int sendCountLimitValue = parameters.CheckTopicSendCountNotGreater.Value; query = query.Where(p => p.SendCount <= sendCountLimitValue); } return(query); }
public virtual IQueryable <Subscriber <long> > CreateSelectQuery(SubscriptionParameters parameters , SubscribersRangeParameters <long> subscribersRange, SenderDbContext context) { IQueryable <SubscriberDeliveryTypeSettingsLong> query = CreateDeliveryTypeSelectQuery(parameters, subscribersRange, context); if (subscribersRange.SelectFromCategories) { IQueryable <SubscriberCategorySettingsLong> categoryQueryPart = CreateCategorySelectQuery(parameters, subscribersRange, context); query = JoinWithCategoriesSelect(parameters, query, categoryQueryPart); } if (subscribersRange.SelectFromTopics) { IQueryable <SubscriberTopicSettingsLong> topicQueryPart = CreateTopicSelectQuery(parameters, subscribersRange, context); query = JoinWithTopicsSelect(parameters, subscribersRange, query, topicQueryPart); } IQueryable <Subscriber <long> > subscribers = query.Select(d => new Subscriber <long> { SubscriberId = d.SubscriberId, DeliveryType = d.DeliveryType, Address = d.Address, TimeZoneId = d.TimeZoneId, Language = d.Language }); if (subscribersRange.Limit != null) { subscribers = subscribers.Take(subscribersRange.Limit.Value); } return(subscribers); }
public static async Task InitializeAsync(IConfiguration config) { SenderDbContextFactory factory = new SenderDbContextFactory(); SenderDbContext dbContext = factory.CreateDbContext(config); await dbContext.InitializeAsync();; }
protected virtual IQueryable <SubscriberDeliveryTypeSettingsLong> CreateDeliveryTypeSelectQuery( SubscriptionParameters parameters, SubscribersRangeParameters <long> subscribersRange, SenderDbContext context) { IQueryable <SubscriberDeliveryTypeSettingsLong> query = context.SubscriberDeliveryTypeSettings .Where(p => p.Address != null); if (subscribersRange.FromSubscriberIds != null) { query = query.Where(p => subscribersRange.FromSubscriberIds.Contains(p.SubscriberId)); } if (subscribersRange.SubscriberIdRangeFromIncludingSelf != null) { query = query.Where(p => subscribersRange.SubscriberIdRangeFromIncludingSelf.Value <= p.SubscriberId); } if (subscribersRange.SubscriberIdRangeToIncludingSelf != null) { query = query.Where(p => p.SubscriberId <= subscribersRange.SubscriberIdRangeToIncludingSelf.Value); } if (subscribersRange.SubscriberIdFromDeliveryTypesHandled != null && subscribersRange.SubscriberIdRangeFromIncludingSelf != null) { query = query.Where( p => p.SubscriberId != subscribersRange.SubscriberIdRangeToIncludingSelf.Value || (p.SubscriberId == subscribersRange.SubscriberIdRangeToIncludingSelf.Value && !subscribersRange.SubscriberIdFromDeliveryTypesHandled.Contains(p.DeliveryType)) ); } if (parameters.DeliveryType != null) { query = query.Where(p => p.DeliveryType == parameters.DeliveryType.Value); } if (parameters.CheckDeliveryTypeEnabled) { query = query.Where(p => p.IsEnabled == true); } if (parameters.CheckDeliveryTypeLastSendDate) { query = query.Where(p => p.LastSendDateUtc == null || (p.LastVisitUtc != null && p.LastSendDateUtc < p.LastVisitUtc)); } if (parameters.CheckDeliveryTypeSendCountNotGreater != null) { int sendCountLimitValue = parameters.CheckDeliveryTypeSendCountNotGreater.Value; query = query.Where(p => p.SendCount <= sendCountLimitValue); } if (parameters.CheckIsNDRBlocked) { query = query.Where(p => p.IsNDRBlocked == false); } return(query); }