[Ignore] // Requires review
public void AsynchronousSyncFiresEvents()
{
SqlSubscriptionManager subMgr = CreateSubscriptionManager();
SubscriptionParameters subParams = CreateSubscriptionParams("PubCustomers", "CustomersTest");
subMgr.Add(subParams);
bool didStartTableDownload = false;
bool didSyncCompletion = false;
bool didSynchronization = false;
Subscription sub = subMgr.Subscriptions[0];
sub.SyncCompleted += delegate { didSyncCompletion = true; };
sub.SyncProgress += delegate { didSynchronization = true; };
sub.TableDownloadStarted += delegate { didStartTableDownload = true; };
subMgr.BeginSynchronize(sub);
sub.AsyncResult.AsyncWaitHandle.WaitOne(asyncTimeout, false);
Assert.IsTrue(didStartTableDownload);
Assert.IsTrue(didSyncCompletion);
Assert.IsTrue(didSynchronization);
subMgr.EndSynchronize(sub);
}
protected override void When()
{
_expectedSubscribers = SubscribersGenerated
.GetList <SubscriberWithMissingData>()
.Where(x => x.HasAddress && x.HasTopicsSettingsEnabled)
.TakeLast(10)
.ToList();
var subscribersRange = new SubscribersRangeParameters <ObjectId>()
{
SelectFromTopics = true,
TopicId = _topicId,
SubscriberIdRangeFromIncludingSelf = _expectedSubscribers.First().SubscriberId,
SubscriberIdRangeToIncludingSelf = _expectedSubscribers.Last().SubscriberId
};
var subscriberParameters = new SubscriptionParameters()
{
DeliveryType = _deliveryType,
CategoryId = _categoryId,
TopicId = _topicId,
CheckTopicEnabled = true,
};
_actualSubscribers = SUT.Select(subscriberParameters, subscribersRange).Result;
}
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);
}
/// <summary>
/// Please see <seealso cref="IEncodeMessageService{T}.Encode" /> for documentation.
/// </summary>
/// <param name="subscriptionParameters">-</param>
/// <returns>-</returns>
public EncodedMessage Encode(SubscriptionParameters subscriptionParameters)
{
var messageHeaderParameters = new MessageHeaderParameters
{
ApplicationMessageId = subscriptionParameters.ApplicationMessageId,
TeamSetContextId = subscriptionParameters.TeamsetContextId ?? "",
TechnicalMessageType = TechnicalMessageTypes.DkeSubscription,
Mode = RequestEnvelope.Types.Mode.Direct
};
var messagePayloadParameters = new MessagePayloadParameters
{
TypeUrl = Subscription.Descriptor.FullName
};
var subscription = new Subscription();
subscriptionParameters.TechnicalMessageTypes?.ForEach(technicalMessageType =>
subscription.TechnicalMessageTypes.Add(technicalMessageType));
messagePayloadParameters.Value = subscription.ToByteString();
var encodedMessage = new EncodedMessage
{
Id = Guid.NewGuid().ToString(),
Content = EncodeMessageService.Encode(messageHeaderParameters, messagePayloadParameters)
};
return(encodedMessage);
}
public void GivenSingleSubscriptionEntryWhenSendingSubscriptionMessageThenTheMessageShouldBeAccepted()
{
var subscriptionService =
new SubscriptionService(new HttpMessagingService(HttpClient));
var subscriptionParameters = new SubscriptionParameters
{
OnboardResponse = OnboardResponse,
TechnicalMessageTypes = new List <Subscription.Types.MessageTypeSubscriptionItem>()
};
var technicalMessageType = new Subscription.Types.MessageTypeSubscriptionItem
{
TechnicalMessageType = TechnicalMessageTypes.ImgPng
};
subscriptionParameters.TechnicalMessageTypes.Add(technicalMessageType);
subscriptionService.Send(subscriptionParameters);
Thread.Sleep(TimeSpan.FromSeconds(5));
var fetchMessageService = new FetchMessageService(HttpClient);
var fetch = fetchMessageService.Fetch(OnboardResponse);
Assert.Single(fetch);
var decodedMessage = DecodeMessageService.Decode(fetch[0].Command.Message);
Assert.Equal(201, decodedMessage.ResponseEnvelope.ResponseCode);
Assert.Equal(ResponseEnvelope.Types.ResponseBodyType.Ack,
decodedMessage.ResponseEnvelope.Type);
}
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);
}
protected virtual string ToCategorySettingsLookupFilter(SubscriptionParameters parameters,
SubscribersRangeParameters <ObjectId> subscribersRange, bool joinOnCategories)
{
string subscriberIdField = FieldDefinitions.GetFieldMappedName <TCategory>(x => x.SubscriberId);
string deliveryTypeField = FieldDefinitions.GetFieldMappedName <TCategory>(x => x.DeliveryType);
string categoryField = FieldDefinitions.GetFieldMappedName <TCategory>(x => x.CategoryId);
string categoriesJoinCondition = joinOnCategories
? $", $eq: [\"${categoryField}\", \"$$category_id\"]"
: "";
var categoryFilter = ToCategorySettingsFilter(parameters, subscribersRange);
string categoryFilterJson = categoryFilter.RenderJson();
return($@"""$and"":
[
{{
""$expr"": {{
$and:
[
{{ $eq: [""${ subscriberIdField }"", ""$$subscriber_id""] }},
{{ $eq: [""${ deliveryTypeField }"", ""$$delivery_type""] }}
{categoriesJoinCondition}
]
}}
}},
{categoryFilterJson}
]");
}
protected override void When()
{
_expectedSubscribers = SubscribersGenerated
.GetList <SubscriberWithMissingData>()
.Where(x => x.HasAddress && x.HasCategorySettingsEnabled)
.TakeLast(10)
.ToList();
var subscribersRange = new SubscribersRangeParameters <ObjectId>()
{
SelectFromCategories = true,
SubscriberIdRangeFromIncludingSelf = _expectedSubscribers.First().SubscriberId,
SubscriberIdRangeToIncludingSelf = _expectedSubscribers.Last().SubscriberId
};
var subscriberParameters = new SubscriptionParameters()
{
DeliveryType = _deliveryType,
CategoryId = _categoryId,
CheckCategoryEnabled = true
};
_queryDurationWatch = Stopwatch.StartNew();
_actualSubscribers = SUT.Select(subscriberParameters, subscribersRange).Result;
_queryDurationWatch.Stop();
}
public PagedList <Subscription> FindByAuthor(SubscriptionParameters parameters)
{
var subscription = FindByCondition(s => s.AuthorId == parameters.UserId);
return(PagedList <Subscription> .ToPagedList(subscription.OrderBy(s => s.SubcriptionDate),
parameters.PageNumber,
parameters.PageSize));
}
public void AddingDuplicateSubscriptionFails()
{
SqlSubscriptionManager subMgr = CreateSubscriptionManager();
SubscriptionParameters sub = CreateSubscriptionParams("PubCustomers", "CustomersTest");
subMgr.Add(sub);
subMgr.Add(sub);
}
public async Task <Subscription> CreateSubscriptionAsync(SubscriptionParameters subscriptionParameters)
{
var subscriptionModel = await RequestClient
.SendAsync <SubscriptionModel>("/v2/subscriptions", HttpMethod.Post, subscriptionParameters)
.ConfigureAwait(false);
return(new Subscription(subscriptionModel, this));
}
public void ContainsKeyReturnsFalseWhenSubscriptionNotPresent()
{
SqlSubscriptionManager subMgr = CreateSubscriptionManager();
SubscriptionParameters subParams = CreateSubscriptionParams("PubCustomers", "CustomersTest");
Assert.IsFalse(subMgr.Subscriptions.ContainsKey("junk"));
subMgr.Add(subParams);
Assert.IsFalse(subMgr.Subscriptions.ContainsKey("junk"));
}
public void ContainsKeyReturnsTrueWhenSubscriptoinExists()
{
SqlSubscriptionManager subMgr = CreateSubscriptionManager();
SubscriptionParameters subParams = CreateSubscriptionParams("PubCustomers", "CustomersTest");
subMgr.Add(subParams);
Assert.IsTrue(subMgr.Subscriptions.ContainsKey("CustomersTest"));
}
/// <summary>
/// Please see <seealso cref="IMessagingService{T}.Send" /> for documentation.
/// </summary>
/// <param name="subscriptionParameters">-</param>
/// <returns>-</returns>
public MessagingResult Send(SubscriptionParameters subscriptionParameters)
{
var encodedMessages = new List <string> {
Encode(subscriptionParameters).Content
};
var messagingParameters = subscriptionParameters.BuildMessagingParameter(encodedMessages);
return(_messagingService.Send(messagingParameters));
}
protected virtual FilterDefinition <TCategory> ToCategorySettingsFilter(
SubscriptionParameters parameters, SubscribersRangeParameters <ObjectId> subscribersRange)
{
var filter = Builders <TCategory> .Filter.Where(p => true);
if (parameters.DeliveryType != null)
{
filter &= Builders <TCategory> .Filter.Where(
p => p.DeliveryType == parameters.DeliveryType.Value);
}
if (parameters.CategoryId != null)
{
filter &= Builders <TCategory> .Filter.Where(
p => p.CategoryId == parameters.CategoryId);
}
if (parameters.CheckCategoryEnabled)
{
filter &= Builders <TCategory> .Filter.Where(p => p.IsEnabled == true);
}
if (parameters.CheckCategorySendCountNotGreater != null)
{
filter &= Builders <TCategory> .Filter.Where(
p => p.SendCount <= parameters.CheckCategorySendCountNotGreater.Value);
}
if (subscribersRange.FromSubscriberIds != null)
{
filter &= Builders <TCategory> .Filter.Where(
p => subscribersRange.FromSubscriberIds.Contains(p.SubscriberId));
}
if (subscribersRange.SubscriberIdRangeFromIncludingSelf != null)
{
filter &= Builders <TCategory> .Filter.Where(
p => subscribersRange.SubscriberIdRangeFromIncludingSelf.Value <= p.SubscriberId);
}
if (subscribersRange.SubscriberIdRangeToIncludingSelf != null)
{
filter &= Builders <TCategory> .Filter.Where(
p => p.SubscriberId <= subscribersRange.SubscriberIdRangeToIncludingSelf.Value);
}
if (subscribersRange.SubscriberIdFromDeliveryTypesHandled != null &&
subscribersRange.SubscriberIdRangeFromIncludingSelf != null)
{
filter &= Builders <TCategory> .Filter.Where(
p => p.SubscriberId != subscribersRange.SubscriberIdRangeToIncludingSelf.Value ||
(p.SubscriberId == subscribersRange.SubscriberIdRangeToIncludingSelf.Value &&
!subscribersRange.SubscriberIdFromDeliveryTypesHandled.Contains(p.DeliveryType)));
}
return(filter);
}
protected virtual PipelineDefinition <TInput, BsonDocument> AddCategoryLookupStages <TInput>(
PipelineDefinition <TInput, BsonDocument> pipeline, SubscriptionParameters parameters,
SubscribersRangeParameters <ObjectId> subscribersRange)
{
if (!subscribersRange.SelectFromCategories)
{
return(pipeline);
}
string categoryCollection = _collectionFactory.GetCollection <TCategory>().CollectionNamespace.CollectionName;
string subscriberIdField = subscribersRange.SelectFromTopics
? FieldDefinitions.GetFieldMappedName <TTopic>(x => x.SubscriberId)
: FieldDefinitions.GetFieldMappedName <TDeliveryType>(x => x.SubscriberId);
string deliveryTypeField = subscribersRange.SelectFromTopics
? FieldDefinitions.GetFieldMappedName <TTopic>(x => x.DeliveryType)
: FieldDefinitions.GetFieldMappedName <TDeliveryType>(x => x.DeliveryType);
string categoryField = FieldDefinitions.GetFieldMappedName <TTopic>(x => x.CategoryId);
string categoriesIntermediateField = "cats";
bool joinOnCategories = subscribersRange.SelectFromTopics;
string joinOnCategory = joinOnCategories
? $", category_id: \"{categoryField}\""
: "";
string matchConditions = ToCategorySettingsLookupFilter(parameters, subscribersRange, joinOnCategories);
string categoriesLookup = $@"
{{
$lookup : {{
from: ""{categoryCollection}"",
let: {{
subscriber_id: ""${subscriberIdField}"",
delivery_type: ""${deliveryTypeField}""
{joinOnCategory}
}},
pipeline: [
{{
$match: {{
{matchConditions}
}}
}},
{{ $project: {{ _id: 1 }} }}
],
as: ""{categoriesIntermediateField}""
}}
}}";
string hasCategoriesStage = $@"
{{ $match: {{
{categoriesIntermediateField}: {{ $exists: true, $ne: [] }}
}}
}}";
return(pipeline
.AppendStage(categoriesLookup, BsonDocumentSerializer.Instance)
.AppendStage(hasCategoriesStage, BsonDocumentSerializer.Instance));
}
public IActionResult GetListSubscribers([FromQuery] SubscriptionParameters parameters)
{
PagedList <Subscription> subscriptions = _repoWrapper.Subscription.FindByAuthor(parameters);
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(subscriptions.MetaData));
List <SubscriptionGetModel> subscriptionGetModels = _statisticService.TransformSubscription(subscriptions);
return(Ok(subscriptionGetModels));
}
public void CanAddSubscription()
{
SqlSubscriptionManager subMgr = CreateSubscriptionManager();
SubscriptionParameters subParams = CreateSubscriptionParams("PubCustomers", "CustomersTest");
subMgr.Add(subParams);
Assert.AreEqual(1, subMgr.Subscriptions.Count);
Assert.AreEqual("CustomersTest", subMgr.Subscriptions[0].Subscriber);
}
public void CanDropSubscriptionAfterAppRestart()
{
SubscriptionParameters subParams = CreateSubscriptionParams("PubCustomers", "CustomersTest");
SqlSubscriptionManager subMgr = CreateSubscriptionManager();
subMgr.Add(subParams);
subMgr = CreateSubscriptionManager();
subMgr.Drop(subMgr.Subscriptions[0]);
Assert.AreEqual(0, subMgr.Subscriptions.Count);
}
[Ignore] // Requires setting up IIS fro subscription
public void PublicationNameIsCorrectAfterSync()
{
SubscriptionParameters subParams = CreateSubscriptionParams("PubCustomers", "CustomersTest");
SqlSubscriptionManager subMgr = CreateSubscriptionManager();
subMgr.Add(subParams);
subMgr.Synchronize(subMgr.Subscriptions[0]);
subMgr = CreateSubscriptionManager();
Assert.AreEqual("PubCustomers", subMgr.Subscriptions[0].Publication);
}
//Select with join
public virtual Task <List <Subscriber <ObjectId> > > Select(
SubscriptionParameters parameters, SubscribersRangeParameters <ObjectId> subscribersRange)
{
if (subscribersRange.SelectFromTopics)
{
return(LookupStartingWithTopics(parameters, subscribersRange));
}
else
{
return(LookupStartingWithDeliveryTypes(parameters, subscribersRange));
}
}
public void AsyncSyncOfOldSubscriptionFails()
{
SubscriptionParameters subParams = CreateSubscriptionParams("PubCustomers", "CustomersTest");
SqlSubscriptionManager subMgr = CreateSubscriptionManager();
subMgr.Add(subParams);
Subscription sub = subMgr.Subscriptions[0];
subMgr = CreateSubscriptionManager();
subMgr.BeginSynchronize(sub);
}
protected virtual IQueryable <SubscriberCategorySettingsLong> CreateCategorySelectQuery(
SubscriptionParameters parameters, SubscribersRangeParameters <long> subscribersRange, SenderDbContext context)
{
IQueryable <SubscriberCategorySettingsLong> query = context.SubscriberCategorySettings;
if (parameters.CategoryId != null)
{
query = query.Where(p => p.CategoryId == parameters.CategoryId);
}
if (parameters.DeliveryType != null)
{
query = query.Where(p => p.DeliveryType == parameters.DeliveryType.Value);
}
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.CheckCategoryEnabled)
{
query = query.Where(p => p.IsEnabled == true);
}
if (parameters.CheckCategorySendCountNotGreater != null)
{
int sendCountLimitValue = parameters.CheckCategorySendCountNotGreater.Value;
query = query.Where(p => p.SendCount <= sendCountLimitValue);
}
return(query);
}
public void SyncingDroppedSubscriptionThrowsException()
{
SubscriptionParameters subParams = CreateSubscriptionParams("PubCustomers", "CustomersTest");
SqlSubscriptionManager subMgr = CreateSubscriptionManager();
subMgr.Add(subParams);
Subscription sub = subMgr.Subscriptions[0];
subMgr.Drop(sub);
subMgr.Synchronize(sub);
}
private static SubscriptionParameters CreateSubscriptionParams(string publication, string subscriber)
{
SubscriptionParameters subscription = new SubscriptionParameters();
subscription.Publication = publication;
subscription.Publisher = "MOBGUISQL01";
subscription.PublisherDatabase = "AdventureWorksMobileStaging";
subscription.InternetUrl = "http://mobguisql01/PublicationCustomers/sqlcesa30.dll";
subscription.Subscriber = subscriber;
subscription.Filter = "DE";
return(subscription);
}
protected virtual IQueryable <SubscriberDeliveryTypeSettingsLong> JoinWithCategoriesSelect(
SubscriptionParameters parameters, IQueryable <SubscriberDeliveryTypeSettingsLong> typeQueryPart
, IQueryable <SubscriberCategorySettingsLong> categoryQueryPart)
{
int categoryIdValue = parameters.CategoryId.Value;
IQueryable <SubscriberDeliveryTypeSettingsLong> query = null;
if (parameters.CheckCategoryLastSendDate)
{
query = from d in typeQueryPart
join c in categoryQueryPart on
new
{
SubscriberId = d.SubscriberId,
DeliveryType = d.DeliveryType,
CategoryId = categoryIdValue
} equals new
{
SubscriberId = c.SubscriberId,
DeliveryType = c.DeliveryType,
CategoryId = c.CategoryId
}
into gr
from catGroup in gr.DefaultIfEmpty()
where catGroup != null &&
(catGroup.LastSendDateUtc == null ||
(d.LastVisitUtc != null && catGroup.LastSendDateUtc < d.LastVisitUtc))
select d;
}
else
{
query = from d in typeQueryPart
join c in categoryQueryPart on
new
{
SubscriberId = d.SubscriberId,
DeliveryType = d.DeliveryType,
CategoryId = categoryIdValue
} equals new
{
SubscriberId = c.SubscriberId,
DeliveryType = c.DeliveryType,
CategoryId = c.CategoryId
}
into gr
from catGroup in gr.DefaultIfEmpty()
select d;
}
return(query);
}
protected virtual FilterDefinition <TTopic> ToTopicSettingsFilter(
SubscriptionParameters parameters, SubscribersRangeParameters <ObjectId> subscribersRange)
{
var filter = Builders <TTopic> .Filter.Where(
p => p.TopicId == subscribersRange.TopicId &&
p.IsDeleted == false);
if (parameters.DeliveryType != null)
{
filter &= Builders <TTopic> .Filter.Where(
p => p.DeliveryType == parameters.DeliveryType.Value);
}
if (parameters.CategoryId != null)
{
filter &= Builders <TTopic> .Filter.Where(
p => p.CategoryId == parameters.CategoryId);
}
if (parameters.CheckTopicEnabled)
{
filter &= Builders <TTopic> .Filter.Where(p => p.IsEnabled);
}
if (parameters.CheckTopicSendCountNotGreater != null)
{
filter = Builders <TTopic> .Filter.Where(
p => p.SendCount <= parameters.CheckTopicSendCountNotGreater.Value);
}
if (subscribersRange.FromSubscriberIds != null)
{
filter &= Builders <TTopic> .Filter.Where(
p => subscribersRange.FromSubscriberIds.Contains(p.SubscriberId));
}
if (subscribersRange.SubscriberIdRangeFromIncludingSelf != null)
{
filter &= Builders <TTopic> .Filter.Where(
p => subscribersRange.SubscriberIdRangeFromIncludingSelf.Value <= p.SubscriberId);
}
if (subscribersRange.SubscriberIdRangeToIncludingSelf != null)
{
filter &= Builders <TTopic> .Filter.Where(
p => p.SubscriberId <= subscribersRange.SubscriberIdRangeToIncludingSelf.Value);
}
return(filter);
}
//filters
public override FilterDefinition <TDeliveryType> ToDeliveryTypeSettingsFilter(
SubscriptionParameters parameters, SubscribersRangeParameters <ObjectId> subscribersRange)
{
var filter = base.ToDeliveryTypeSettingsFilter(parameters, subscribersRange);
if (subscribersRange.SelectFromCategories)
{
var categoriesFilter = ToCategorySettingsFilter(parameters, subscribersRange);
filter &= Builders <TDeliveryType> .Filter
.ElemMatch(x => x.SubscriberCategorySettings, categoriesFilter);
}
return(filter);
}
[Ignore] // Requires setting up IIS fro subscription
public void LastSyncTimeBecomesNonNullAfterSync()
{
SubscriptionParameters subParams = CreateSubscriptionParams("PubCustomers", "CustomersTest");
SqlSubscriptionManager subMgr = CreateSubscriptionManager();
subMgr.Add(subParams);
Subscription sub = subMgr.Subscriptions[0];
Assert.IsNull(sub.LastSyncTime);
subMgr.Synchronize(sub);
subMgr = CreateSubscriptionManager();
Assert.IsNotNull(sub.LastSyncTime);
}
//select
public virtual async Task <List <Subscriber <long> > > Select(
SubscriptionParameters parameters, SubscribersRangeParameters <long> subscribersRange)
{
List <Subscriber <long> > subscribers = null;
using (var context = _dbContextFactory.GetDbContext())
{
IQueryable <Subscriber <long> > query =
CreateSelectQuery(parameters, subscribersRange, context);
subscribers = await query.ToListAsync().ConfigureAwait(false);
}
return(subscribers);
}
