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