/// <summary>
/// Initialises the database.
/// </summary>
/// <param name="serviceProvider">The service provider.</param>
/// <returns></returns>
private static async Task InitialiseDatabase(IServiceProvider serviceProvider)
{
using (IServiceScope scope = serviceProvider.GetService <IServiceScopeFactory>().CreateScope())
{
SubscriptionServiceConfigurationContext subscriptionServiceConfigurationContext = scope.ServiceProvider.GetRequiredService <SubscriptionServiceConfigurationContext>();
DatabaseSeeding.InitialiseDatabase(subscriptionServiceConfigurationContext);
}
}
/// <summary>
/// Gets the event store server.
/// </summary>
/// <param name="eventStoreServerId">The event store server identifier.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <EventStoreServer> GetEventStoreServer(Guid eventStoreServerId,
CancellationToken cancellationToken)
{
EventStoreServer result = new EventStoreServer();
using (SubscriptionServiceConfigurationContext context = this.ContextResolver())
{
Database.Models.EventStoreServer eventStoreServer = await context.EventStoreServers.Where(s => s.EventStoreServerId == eventStoreServerId).SingleOrDefaultAsync(cancellationToken);
result.EventStoreServerId = eventStoreServer.EventStoreServerId;
result.ConnectionString = eventStoreServer.ConnectionString;
result.Name = eventStoreServer.Name;
}
return(result);
}
/// <summary>
/// Deletes the catch up subscription.
/// </summary>
/// <param name="catchUpSubscriptionId">The catch up subscription identifier.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <exception cref="NotFoundException">Catch Up Subscription Group with Id {catchUpSubscriptionId} not found</exception>
public async Task DeleteCatchUpSubscription(Guid catchUpSubscriptionId,
CancellationToken cancellationToken)
{
Guard.ThrowIfInvalidGuid(catchUpSubscriptionId, typeof(ArgumentNullException), "A catchup subscription Id must be provided");
using (SubscriptionServiceConfigurationContext context = this.ContextResolver())
{
Database.Models.CatchupSubscriptionConfiguration catchUpSubscriptionConfiguration = await context.CatchupSubscriptionConfigurations.Where(c => c.SubscriptionId == catchUpSubscriptionId)
.SingleOrDefaultAsync(cancellationToken);
if (catchUpSubscriptionConfiguration == null)
{
throw new NotFoundException($"Catch Up Subscription Group with Id {catchUpSubscriptionId} not found");
}
context.CatchupSubscriptionConfigurations.Remove(catchUpSubscriptionConfiguration);
await context.SaveChangesAsync(cancellationToken);
}
}
/// <summary>
/// Resets the subscription stream position.
/// </summary>
/// <param name="subscriptionId">The subscription identifier.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <exception cref="NotFoundException">Subscription Group with Id {subscriptionConfiguration} not found</exception>
public async Task ResetSubscriptionStreamPosition(Guid subscriptionId,
CancellationToken cancellationToken)
{
Guard.ThrowIfInvalidGuid(subscriptionId, typeof(ArgumentNullException), "A subscription group Id must be provided");
using (SubscriptionServiceConfigurationContext context = this.ContextResolver())
{
Database.Models.SubscriptionConfiguration subscriptionConfiguration = await context.SubscriptionConfigurations.Where(g => g.SubscriptionId == subscriptionId)
.SingleOrDefaultAsync(cancellationToken);
if (subscriptionConfiguration == null)
{
throw new NotFoundException($"Subscription Group with Id {subscriptionConfiguration} not found");
}
// Reset the Stream Position
subscriptionConfiguration.StreamPosition = null;
await context.SaveChangesAsync(cancellationToken);
}
}
/// <summary>
/// Gets the subscription configuration.
/// </summary>
/// <param name="subscriptionId">The subscription identifier.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <SubscriptionConfiguration> GetSubscriptionConfiguration(Guid subscriptionId,
CancellationToken cancellationToken)
{
SubscriptionConfiguration result = new SubscriptionConfiguration();
using (SubscriptionServiceConfigurationContext context = this.ContextResolver())
{
Database.Models.SubscriptionConfiguration subscriptionConfiguration =
await context.SubscriptionConfigurations.Where(s => s.SubscriptionId == subscriptionId).SingleOrDefaultAsync(cancellationToken);
result = new SubscriptionConfiguration
{
EventStoreServerId = subscriptionConfiguration.EventStoreServerId,
EndPointUri = subscriptionConfiguration.EndPointUri,
GroupName = subscriptionConfiguration.GroupName,
StreamName = subscriptionConfiguration.StreamName,
StreamPositionToRestartFrom = subscriptionConfiguration.StreamPosition,
SubscriptionId = subscriptionConfiguration.SubscriptionId
};
}
return(result);
}
public async Task <CatchupSubscriptionConfiguration> GetCatchupSubscriptionConfiguration(Guid subscriptionId,
CancellationToken cancellationToken)
{
CatchupSubscriptionConfiguration result = new CatchupSubscriptionConfiguration();
using (SubscriptionServiceConfigurationContext context = this.ContextResolver())
{
Database.Models.CatchupSubscriptionConfiguration catchupSubscriptionConfiguration =
await context.CatchupSubscriptionConfigurations.Where(s => s.SubscriptionId == subscriptionId).SingleOrDefaultAsync(cancellationToken);
result = new CatchupSubscriptionConfiguration
{
EventStoreServerId = catchupSubscriptionConfiguration.EventStoreServerId,
EndPointUri = catchupSubscriptionConfiguration.EndPointUri,
Name = catchupSubscriptionConfiguration.Name,
StreamName = catchupSubscriptionConfiguration.StreamName,
Position = catchupSubscriptionConfiguration.Position,
SubscriptionId = catchupSubscriptionConfiguration.SubscriptionId,
CreateDateTime = catchupSubscriptionConfiguration.CreateDateTime
};
}
return(result);
}
