public ConfigBasedStoreInitializer(
EntityFrameworkOptions options,
ApplicationOptions appOptions,
ILogger <ConfigBasedStoreInitializer> logger,
MigrationDbContext migrationDbContext,
IConfigurationDbContext configurationDbContext,
IPersistedGrantDbContext persistedGrantDbContext,
IUserAccountDbContext userAccountDbContext,
IHostingEnvironment environment,
IServiceProvider serviceProvider)
{
this._options = options;
this._appOptions = appOptions;
this._logger = logger;
this._migrationDbContext = migrationDbContext;
this._configurationDbContext = configurationDbContext;
this._persistedGrantDbContext = persistedGrantDbContext;
this._userAccountDbContext = userAccountDbContext;
this._environment = environment;
this._serviceProvider = serviceProvider ??
throw new ArgumentNullException(nameof(serviceProvider));
this._logger.LogDebug("ConfigBasedStoreInitializer initialized");
}
/// <summary>
/// Creates a new instance of <see cref="DynamicScopePersistedGrantService{T}"/>.
/// </summary>
/// <param name="inner">Implements persisted grant logic.</param>
/// <param name="persistedGrantDbContext">Abstraction for the operational data context.</param>
/// <param name="dynamicScopeNotificationService">Contains methods to notify an API when a dynamic consent is altered.</param>
/// <param name="serializer">Interface for persisted grant serialization.</param>
public DynamicScopePersistedGrantService(T inner, IPersistedGrantDbContext persistedGrantDbContext, IDynamicScopeNotificationService dynamicScopeNotificationService, IPersistentGrantSerializer serializer)
{
_inner = inner;
_persistedGrantDbContext = persistedGrantDbContext ?? throw new ArgumentNullException(nameof(persistedGrantDbContext));
_dynamicScopeNotificationService = dynamicScopeNotificationService ?? throw new ArgumentNullException(nameof(dynamicScopeNotificationService));
_serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
}
private Task RemoveDeviceCodes(IPersistedGrantDbContext context)
{
var found = Int32.MaxValue;
while (found >= _options.TokenCleanupBatchSize)
{
var expiredCodes = context.DeviceFlowCodes
.Where(x => x.Expiration < DateTime.UtcNow)
.Take(_options.TokenCleanupBatchSize)
.ToArray();
found = expiredCodes.Length;
_logger.LogInformation("Removing {deviceCodeCount} device flow codes", found);
if (found > 0)
{
context.DeviceFlowCodes.RemoveRange(expiredCodes);
try
{
context.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
// we get this if/when someone else already deleted the records
// we want to essentially ignore this, and keep working
_logger.LogDebug("Concurrency exception removing expired grants: {exception}", ex.Message);
}
}
}
return(Task.CompletedTask);
}
/// <summary>
/// Initializes a new instance of the <see cref="PersistedGrantStore"/>
/// class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="logger">The logger.</param>
public PersistedGrantStore(
IPersistedGrantDbContext context,
ILogger <PersistedGrantStore> logger)
{
this._context = context;
this._logger = logger;
}
public void ClearTokens()
{
try
{
_logger.LogTrace("Querying for tokens to clear", Array.Empty <object>());
using (IServiceScope scope = _serviceProvider.GetRequiredService <IServiceScopeFactory>().CreateScope())
{
using (IPersistedGrantDbContext service = scope.ServiceProvider.GetService <IPersistedGrantDbContext>())
{
PersistedGrant[] array = service.PersistedGrants.Where(x => x.Expiration < (DateTimeOffset?)DateTimeOffset.UtcNow).ToArray();
_logger.LogInformation("Clearing {tokenCount} tokens", (object)array.Length);
if (array.Length == 0)
{
return;
}
service.PersistedGrants.RemoveRange(array);
service.SaveChanges();
}
}
}
catch (Exception ex)
{
_logger.LogError("Exception clearing tokens: {exception}", (object)ex.Message);
}
}
public void ClearTokens()
{
this._logger.LogTrace("Querying for tokens to clear");
using (IServiceScope serviceScope = this._serviceProvider
.GetRequiredService <IServiceScopeFactory>().CreateScope())
{
using (IPersistedGrantDbContext context = serviceScope
.ServiceProvider.GetService <IPersistedGrantDbContext>())
{
PersistedGrant[] expired = context.PersistedGrants
.Where(x => x.Expiration < DateTimeOffset.UtcNow)
.ToArray();
this._logger.LogInformation(
"Clearing {tokenCount} tokens",
expired.Length);
if (expired.Length > 0)
{
context.PersistedGrants.RemoveRange(expired);
context.SaveChanges();
}
}
}
}
public DeviceFlowStore(IPersistedGrantDbContext context,
IPersistentGrantSerializer serializer,
ILogger <DeviceFlowStore> logger)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
_serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public PersistedGrantStore(IPersistedGrantDbContext context, ILogger <PersistedGrantStore> logger)
{
Guard.ForNull(context, nameof(context));
Guard.ForNull(logger, nameof(logger));
_context = context;
_logger = logger;
}
public PersistedGrantStore(
IPersistedGrantDbContext context,
ILogger <PersistedGrantStore> logger
)
{
_repository = context;
_logger = logger;
}
// private readonly UserStore<ApplicationUser> _userStore;
public UserController(UserManager <ApplicationUser> userManager, IConfigurationDbContext configDbContext,
IPersistedGrantDbContext persistedDbContext, RoleManager <ApplicationRole> roleMager)
{
_userManager = userManager;
_configDbContext = configDbContext;
_persistedDbContext = persistedDbContext;
_roleMager = roleMager;
}
public PersistedGrantStore(
IHttpContextAccessor contextAccessor,
IPersistedGrantDbContext context,
ILogger<PersistedGrantStore> logger)
{
_contextAccessor = contextAccessor;
_context = context;
_logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="DeviceFlowStore"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="serializer">The serializer</param>
/// <param name="logger">The logger.</param>
public DeviceFlowStore(
IPersistedGrantDbContext context,
IPersistentGrantSerializer serializer,
ILogger <DeviceFlowStore> logger)
{
Context = context;
Serializer = serializer;
Logger = logger;
}
public PersistedGrantStore(
IHttpContextAccessor contextAccessor,
IPersistedGrantDbContext context,
ILogger <PersistedGrantStore> logger)
{
_contextAccessor = contextAccessor;
_context = context;
_logger = logger;
}
/// <summary>
/// Creates a new instance of <see cref="ParsedScopePersistedGrantService{T}"/>.
/// </summary>
/// <param name="inner">Implements persisted grant logic.</param>
/// <param name="persistedGrantDbContext">Abstraction for the operational data context.</param>
/// <param name="parsedScopeNotificationService">Contains methods to notify an API when a dynamic consent is altered.</param>
/// <param name="serializer">Interface for persisted grant serialization.</param>
/// <param name="scopeParser">Allows parsing raw scopes values into structured scope values.</param>
public ParsedScopePersistedGrantService(TPersistedGrantService inner, IPersistedGrantDbContext persistedGrantDbContext, IParsedScopeNotificationService parsedScopeNotificationService, IPersistentGrantSerializer serializer,
IScopeParser scopeParser)
{
_inner = inner;
_persistedGrantDbContext = persistedGrantDbContext ?? throw new ArgumentNullException(nameof(persistedGrantDbContext));
_parsedScopeNotificationService = parsedScopeNotificationService ?? throw new ArgumentNullException(nameof(parsedScopeNotificationService));
_serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
_scopeParser = scopeParser ?? throw new ArgumentNullException(nameof(scopeParser));
}
public PersistedGrantStore(
SiteContext site,
IPersistedGrantDbContext context,
ILogger <PersistedGrantStore> logger)
{
_siteId = site.Id.ToString();
_context = context;
_logger = logger;
}
public OidcConfigurationController(
IClientRequestParametersProvider clientRequestParametersProvider,
ILogger <OidcConfigurationController> _logger,
IPersistedGrantDbContext context)
{
ClientRequestParametersProvider = clientRequestParametersProvider;
logger = _logger;
var list = context.PersistedGrants.ToList();
}
/// <summary>
/// Initializes a new instance of the <see cref="DeviceFlowStore"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="serializer">The serializer</param>
/// <param name="logger">The logger.</param>
/// <param name="cancellationTokenProvider"></param>
public DeviceFlowStore(
IPersistedGrantDbContext context,
IPersistentGrantSerializer serializer,
ILogger <DeviceFlowStore> logger,
ICancellationTokenProvider cancellationTokenProvider)
{
Context = context;
Serializer = serializer;
Logger = logger;
CancellationTokenProvider = cancellationTokenProvider;
}
public DeviceFlowStore(
IHttpContextAccessor contextAccessor,
IPersistedGrantDbContext context,
IPersistentGrantSerializer serializer,
ILogger <DeviceFlowStore> logger
)
{
_contextAccessor = contextAccessor;
_context = context;
_serializer = serializer;
_logger = logger;
}
public PersistedGrantStore(IPersistedGrantDbContext context, ILogger <PersistedGrantStore> logger)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_context = context;
_logger = logger;
}
public DefaultStoreInitializer(
EntityFrameworkOptions options,
ILogger <DefaultStoreInitializer> logger,
DefaultDbContext defaultDbContext,
IConfigurationDbContext configurationDbContext,
IPersistedGrantDbContext persistedGrantDbContext,
IUserAccountDbContext userAccountDbContext)
{
_options = options;
_logger = logger;
_defaultDbContext = defaultDbContext;
_configurationDbContext = configurationDbContext;
_persistedGrantDbContext = persistedGrantDbContext;
_userAccountDbContext = userAccountDbContext;
}
/// <summary>
/// Constructor for TokenCleanupService.
/// </summary>
/// <param name="options"></param>
/// <param name="persistedGrantDbContext"></param>
/// <param name="operationalStoreNotification"></param>
/// <param name="logger"></param>
public TokenCleanupService(
OperationalStoreOptions options,
IPersistedGrantDbContext persistedGrantDbContext,
ILogger <TokenCleanupService> logger,
IOperationalStoreNotification operationalStoreNotification = null)
{
_options = options ?? throw new ArgumentNullException(nameof(options));
if (_options.TokenCleanupBatchSize < 1)
{
throw new ArgumentException("Token cleanup batch size interval must be at least 1");
}
_persistedGrantDbContext = persistedGrantDbContext ?? throw new ArgumentNullException(nameof(persistedGrantDbContext));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_operationalStoreNotification = operationalStoreNotification;
}
public ExampleDataStoreInitializer(
EntityFrameworkOptions options,
ApplicationOptions appOptions,
ILogger <ConfigBasedStoreInitializer> logger,
MigrationDbContext migrationDbContext,
IConfigurationDbContext configurationDbContext,
IPersistedGrantDbContext persistedGrantDbContext,
IUserAccountDbContext userAccountDbContext,
ICrypto crypto)
{
this.options = options;
this.appOptions = appOptions;
this.logger = logger;
this.migrationDbContext = migrationDbContext;
this.configurationDbContext = configurationDbContext;
this.persistedGrantDbContext = persistedGrantDbContext;
this.userAccountDbContext = userAccountDbContext;
this.crypto = crypto;
}
private async Task RemoveGrants(IPersistedGrantDbContext context, IOperationalStoreNotification tokenCleanupNotification)
{
var found = Int32.MaxValue;
while (found >= _options.TokenCleanupBatchSize)
{
var expiredGrants = context.PersistedGrants
.Where(x => x.Expiration < DateTime.UtcNow)
.OrderBy(x => x.Key)
.Take(_options.TokenCleanupBatchSize)
.ToArray();
found = expiredGrants.Length;
_logger.LogInformation("Removing {grantCount} grants", found);
if (found > 0)
{
context.PersistedGrants.RemoveRange(expiredGrants);
try
{
context.SaveChanges();
if (tokenCleanupNotification != null)
{
await tokenCleanupNotification.PersistedGrantsRemovedAsync(expiredGrants);
}
}
catch (DbUpdateConcurrencyException ex)
{
// we get this if/when someone else already deleted the records
// we want to essentially ignore this, and keep working
_logger.LogDebug("Concurrency exception removing expired grants: {exception}", ex.Message);
}
}
}
}
/// <summary>
/// Saves changes and handles concurrency exceptions.
/// </summary>
public static async Task <ICollection <T> > SaveChangesWithConcurrencyCheckAsync <T>(this IPersistedGrantDbContext context, ILogger logger, CancellationToken cancellationToken = default)
where T : class
{
var list = new List <T>();
var count = 3;
while (count > 0)
{
try
{
await context.SaveChangesAsync(cancellationToken);
return(list);
}
catch (DbUpdateConcurrencyException ex)
{
count--;
// we get this if/when someone else already deleted the records
// we want to essentially ignore this, and keep working
logger.LogDebug("Concurrency exception removing records: {exception}", ex.Message);
foreach (var entry in ex.Entries)
{
// mark this entry as not attached anymore so we don't try to re-delete
entry.State = EntityState.Detached;
list.Add((T)entry.Entity);
}
}
}
logger.LogDebug("Too many concurrency exceptions. Exiting.");
return(list);
}
/// <summary>
/// Initializes a new instance of the <see cref="PersistedGrantStore"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="logger">The logger.</param>
/// <param name="cancellationTokenProvider"></param>
public PersistedGrantStore(IPersistedGrantDbContext context, ILogger <PersistedGrantStore> logger, ICancellationTokenProvider cancellationTokenProvider)
{
Context = context;
Logger = logger;
CancellationTokenProvider = cancellationTokenProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="SigningKeyStore"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="logger">The logger.</param>
/// <exception cref="ArgumentNullException">context</exception>
public SigningKeyStore(IPersistedGrantDbContext context, ILogger <SigningKeyStore> logger)
{
Context = context ?? throw new ArgumentNullException(nameof(context));
Logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="ServerSideSessionStore"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="logger">The logger.</param>
/// <param name="cancellationTokenProvider"></param>
/// <exception cref="ArgumentNullException">context</exception>
public ServerSideSessionStore(IPersistedGrantDbContext context, ILogger <ServerSideSessionStore> logger, ICancellationTokenProvider cancellationTokenProvider)
{
Context = context ?? throw new ArgumentNullException(nameof(context));
Logger = logger;
CancellationTokenProvider = cancellationTokenProvider;
}
public PersistedGrantRepository(IPersistedGrantDbContext context)
{
this.DbSet = context.PersistedGrants;
}
public DeleteModel(IPersistedGrantDbContext context)
{
_context = context;
}
public PersistedGrantStore(IPersistedGrantDbContext context, AppDbContext appContext, ILogger <PersistedGrantStore> logger)
{
_context = context;
_logger = logger;
_appContext = appContext;
}
public IndexModel(IPersistedGrantDbContext context)
{
_context = context;
}
