public CzarIntrospectionRequestValidator(ITokenValidator tokenValidator, DapperStoreOptions config, ICache <CzarToken> cache, ILogger <CzarIntrospectionRequestValidator> logger)
{
_tokenValidator = tokenValidator;
_config = config;
_cache = cache;
_logger = logger;
}
/// <summary>
/// Add a custom implementation for <see cref="UsersTable{TUser, TKey, TUserClaim, TUserRole, TUserLogin, TUserToken}"/>.
/// </summary>
/// <typeparam name="TUsersTable">The type of the table to register.</typeparam>
/// <typeparam name="TUser">The type representing a user.</typeparam>
/// <typeparam name="TKey">The type of the primary key for a role and user.</typeparam>
/// <param name="options">Options for configuring Dapper stores.</param>
public static void AddUsersTable <TUsersTable, TUser, TKey>(this DapperStoreOptions options)
where TUsersTable : UsersTable <TUser, TKey, IdentityUserClaim <TKey>, IdentityUserRole <TKey>, IdentityUserLogin <TKey>, IdentityUserToken <TKey> >
where TUser : IdentityUser <TKey>
where TKey : IEquatable <TKey>
{
options.AddUsersTable <TUsersTable, TUser, TKey, IdentityUserClaim <TKey>, IdentityUserRole <TKey>, IdentityUserLogin <TKey>, IdentityUserToken <TKey> >();
}
/// <summary>
/// Add a custom implementation for <see cref="UserClaimsTable{TKey, TUserClaim}"/>.
/// </summary>
/// <typeparam name="TUserClaimsTable">The type of the table to register.</typeparam>
/// <typeparam name="TKey">The type of the primary key for a user.</typeparam>
/// <typeparam name="TUserClaim">The type representing a claim.</typeparam>
/// <param name="options">Options for configuring Dapper stores.</param>
public static void AddUserClaimsTable <TUserClaimsTable, TKey, TUserClaim>(this DapperStoreOptions options)
where TUserClaimsTable : UserClaimsTable <TKey, TUserClaim>
where TKey : IEquatable <TKey>
where TUserClaim : IdentityUserClaim <TKey>, new()
{
options.Services.AddScoped(typeof(IUserClaimsTable <,>).MakeGenericType(typeof(TKey), typeof(TUserClaim)), typeof(TUserClaimsTable));
}
/// <summary>
/// Add a custom implementation for
/// <see cref="UsersRecord{TUser, TKey, TUserClaim, TUserRole, TUserLogin, TUserToken}" />.
/// </summary>
/// <typeparam name="TUsersRecord">The type of the table to register.</typeparam>
/// <typeparam name="TUser">The type representing a user.</typeparam>
/// <param name="options">Options for configuring Dapper stores.</param>
public static void AddUsersRecord <TUsersRecord, TUser>(this DapperStoreOptions options)
where TUsersRecord : UsersRecord <TUser, string, IdentityUserClaim <string>, IdentityUserRole <string>,
IdentityUserLogin <string>, IdentityUserToken <string> >
where TUser : IdentityUser <string>
{
options.AddUsersRecord <TUsersRecord, TUser, string>();
}
/// <summary>
/// Add a custom implementation for <see cref="UserTokensRecord{TKey, TUserToken}" />.
/// </summary>
/// <typeparam name="TUserTokensRecord">The type of the table to register.</typeparam>
/// <typeparam name="TKey">The type of the primary key for a role and user.</typeparam>
/// <typeparam name="TUserToken">The type representing a user token.</typeparam>
/// <param name="options">Options for configuring Dapper stores.</param>
public static void AddUserTokensRecord <TUserTokensRecord, TKey, TUserToken>(this DapperStoreOptions options)
where TUserTokensRecord : UserTokensRecord <TKey, TUserToken>
where TKey : IEquatable <TKey>
where TUserToken : IdentityUserToken <TKey>, new()
{
options.Services.AddScoped(typeof(IUserTokensRecord <,>).MakeGenericType(typeof(TKey), typeof(TUserToken)),
typeof(TUserTokensRecord));
}
/// <summary>
/// Add a custom implementation for <see cref="RoleClaimsRecord{TKey, TRoleClaim}" />.
/// </summary>
/// <typeparam name="TRoleClaimsRecord">The type of the table to register.</typeparam>
/// <typeparam name="TKey">The type of the primary key for a role.</typeparam>
/// <typeparam name="TRoleClaim">The type of the class representing a role claim.</typeparam>
/// <param name="options">Options for configuring Dapper stores.</param>
public static void AddRoleClaimsRecord <TRoleClaimsRecord, TKey, TRoleClaim>(this DapperStoreOptions options)
where TRoleClaimsRecord : RoleClaimsRecord <TKey, TRoleClaim>
where TKey : IEquatable <TKey>
where TRoleClaim : IdentityRoleClaim <TKey>, new()
{
options.Services.AddScoped(typeof(IRoleClaimsRecord <,>).MakeGenericType(typeof(TKey), typeof(TRoleClaim)),
typeof(TRoleClaimsRecord));
}
public TokenCleanup(IPersistedGrants persistedGrants, ILogger <TokenCleanup> logger, DapperStoreOptions options)
{
_options = options ?? throw new ArgumentNullException(nameof(options));
if (_options.TokenCleanupInterval < 1)
{
throw new ArgumentException("Token cleanup interval must be at least 1 second");
}
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_persistedGrants = persistedGrants;
}
/// <summary>
/// Add a custom implementation for
/// <see cref="UsersRecord{TUser, TKey, TUserClaim, TUserRole, TUserLogin, TUserToken}" />.
/// </summary>
/// <typeparam name="TUsersRecord">The type of the table to register.</typeparam>
/// <typeparam name="TUser">The type representing a user.</typeparam>
/// <typeparam name="TKey">The type of the primary key for a role and user.</typeparam>
/// <typeparam name="TUserClaim">The type representing a claim.</typeparam>
/// <typeparam name="TUserRole">The type representing a user role.</typeparam>
/// <typeparam name="TUserLogin">The type representing a user external login.</typeparam>
/// <typeparam name="TUserToken">The type representing a user token.</typeparam>
/// <param name="options">Options for configuring Dapper stores.</param>
public static void AddUsersRecord <TUsersRecord, TUser, TKey, TUserClaim, TUserRole, TUserLogin, TUserToken>(
this DapperStoreOptions options)
where TUsersRecord : UsersRecord <TUser, TKey, TUserClaim, TUserRole, TUserLogin, TUserToken>
where TUser : IdentityUser <TKey>
where TKey : IEquatable <TKey>
where TUserClaim : IdentityUserClaim <TKey>, new()
where TUserRole : IdentityUserRole <TKey>, new()
where TUserLogin : IdentityUserLogin <TKey>, new()
where TUserToken : IdentityUserToken <TKey>, new()
{
options.Services.AddScoped(
typeof(IUsersRecord <, , , , ,>).MakeGenericType(typeof(TUser), typeof(TKey), typeof(TUserClaim),
typeof(TUserRole), typeof(TUserLogin), typeof(TUserToken)), typeof(TUsersRecord));
}
/// <summary>
/// 配置Dapper接口和实现(默认使用SqlServer)
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="storeOptionsAction">存储配置信息</param>
/// <returns></returns>
public static IIdentityServerBuilder AddDapperStore(
this IIdentityServerBuilder builder,
Action <DapperStoreOptions> storeOptionsAction = null)
{
var options = new DapperStoreOptions();
builder.Services.AddSingleton(options);
storeOptionsAction?.Invoke(options);
builder.Services.AddSingleton <TokenCleanup>();
builder.Services.AddSingleton <IHostedService, TokenCleanupHost>();
builder.Services.AddSingleton <ITokenResponseGenerator, CusTokenResponseGenerator>();
builder.Services.AddTransient(typeof(ICache <>), typeof(MemoryCache <>));
builder.Services.AddTransient <IIntrospectionRequestValidator, IntrospectionRequestValidator>();
return(builder);
}
public static IIdentityServerBuilder AddDapperStore(
this IIdentityServerBuilder builder,
Action <DapperStoreOptions> storeOptionsAction)
{
var options = new DapperStoreOptions();
builder.Services.AddSingleton(options);
storeOptionsAction?.Invoke(options);
builder.Services.AddTransient <IClientStore, SqlServerClientStore>();
builder.Services.AddTransient <IResourceStore, SqlServerResourceStore>();
builder.Services.AddTransient <IPersistedGrantStore, SqlServerPersistedGrantStore>();
builder.Services.AddTransient <IPersistedGrants, SqlServerPersistedGrants>();
builder.Services.AddSingleton <TokenCleanup>();
builder.Services.AddSingleton <IHostedService, TokenCleanupHost>();
return(builder);
}
public RedisCache(DapperStoreOptions configurationStoreOptions)
{
CSRedis.CSRedisClient csredis;
if (configurationStoreOptions.RedisConnectionStrings.Count == 1)
{
//普通模式
csredis = new CSRedis.CSRedisClient(configurationStoreOptions.RedisConnectionStrings[0]);
}
else
{
//集群模式
//实现思路：根据key.GetHashCode() % 节点总数量，确定连向的节点
//也可以自定义规则(第一个参数设置)
csredis = new CSRedis.CSRedisClient(item => item, configurationStoreOptions.RedisConnectionStrings.ToArray());
}
//初始化 RedisHelper
RedisHelper.Initialization(csredis);
}
/// <summary>
/// 配置Dapper接口和实现(默认使用SqlServer)
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="storeOptionsAction">存储配置信息</param>
/// <returns></returns>
public static IIdentityServerBuilder AddDapperStore(
this IIdentityServerBuilder builder,
Action <DapperStoreOptions> storeOptionsAction = null)
{
var options = new DapperStoreOptions();
builder.Services.AddSingleton(options);
storeOptionsAction?.Invoke(options);
builder.Services.AddTransient <IClientStore, SqlServerClientStore>();
builder.Services.AddTransient <IResourceStore, SqlServerResourceStore>();
builder.Services.AddTransient <IPersistedGrantStore, SqlServerPersistedGrantStore>();
builder.Services.AddTransient <IPersistedGrants, SqlServerPersistedGrants>();
builder.Services.AddSingleton <TokenCleanup>();
builder.Services.AddSingleton <IHostedService, TokenCleanupHost>();
builder.Services.AddSingleton <ITokenResponseGenerator, CzarTokenResponseGenerator>();
builder.Services.AddTransient(typeof(ICache <>), typeof(CzarRedisCache <>));
builder.Services.AddTransient <IIntrospectionRequestValidator, CzarIntrospectionRequestValidator>();
return(builder);
}
/// <summary>
/// 配置Dapper接口和实现(默认使用SqlServer)
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="storeOptionsAction">存储配置信息</param>
/// <returns></returns>
public static IIdentityServerBuilder AddDapperStore(
this IIdentityServerBuilder builder,
Action <DapperStoreOptions> storeOptionsAction = null)
{
var options = new DapperStoreOptions();
builder.Services.AddSingleton(options);
storeOptionsAction?.Invoke(options);
builder.Services.AddTransient <IClientStore, SqlServerClientStore>();
builder.Services.AddTransient <IResourceStore, SqlServerResourceStore>();
builder.Services.AddTransient <IPersistedGrantStore, SqlServerPersistedGrantStore>();
builder.Services.AddTransient <IPersistedGrants, SqlServerPersistedGrants>();
//builder.Services.AddTransient<IHandleGenerationService, DefaultHandleGenerationService>();
//builder.Services.AddTransient<IPersistentGrantSerializer, PersistentGrantSerializer>();
//builder.Services.AddTransient<IReferenceTokenStore, DefaultReferenceTokenStore>();
builder.Services.AddSingleton <TokenCleanup>();
builder.Services.AddSingleton <IHostedService, TokenCleanupHost>();
return(builder);
}
public static IIdentityServerBuilder AddDapperStore(this IIdentityServerBuilder builder, Action <DapperStoreOptions> options = null)
{
var opts = new DapperStoreOptions();
builder.Services.AddSingleton(opts);
options?.Invoke(opts);
builder.AddClientStore <ClientStore>();
builder.AddResourceStore <ResourceStore>();
builder.AddCorsPolicyService <CorsPolicyService>();
builder.AddInMemoryCaching();
builder.AddClientStoreCache <ClientStore>();
builder.AddResourceStoreCache <ResourceStore>();
builder.AddCorsPolicyCache <CorsPolicyService>();
builder.Services.AddTransient <IPersistedGrantStore, PersistedGrantStore>();
builder.Services.AddTransient <IDeviceFlowStore, DeviceFlowStore>();
builder.Services.AddSingleton <TokenCleanup>();
builder.Services.AddSingleton <IHostedService, TokenCleanupHostedService>();
return(builder);
}
public ClientStore(DapperStoreOptions dapperStoreOptions)
{
_dapperStoreOptions = dapperStoreOptions;
}
public ResourceStore(DapperStoreOptions dapperStoreOptions)
{
_dapperStoreOptions = dapperStoreOptions;
}
public PersistedGrantStore(DapperStoreOptions dapperStoreOptions)
{
_dapperStoreOptions = dapperStoreOptions;
}
public TokenCleanupHost(TokenCleanup tokenCleanup, DapperStoreOptions options)
{
_tokenCleanup = tokenCleanup;
_options = options;
}
public CzarTokenResponseGenerator(ISystemClock clock, ITokenService tokenService, IRefreshTokenService refreshTokenService, IResourceStore resources, IClientStore clients, ILogger <TokenResponseGenerator> logger, DapperStoreOptions config, ICache <CzarToken> cache) : base(clock, tokenService, refreshTokenService, resources, clients, logger)
{
_config = config;
_cache = cache;
}
public MySqlPersistedGrantStore(ILogger <MySqlPersistedGrantStore> logger, DapperStoreOptions configurationStoreOptions)
{
_logger = logger;
_configurationStoreOptions = configurationStoreOptions;
}
/// <summary>
/// Add a custom implementation for <see cref="UserClaimsRecord{TKey, TUserClaim}" />.
/// </summary>
/// <typeparam name="TUserClaimsRecord">The type of the table to register.</typeparam>
/// <typeparam name="TUserClaim">The type representing a claim.</typeparam>
/// <param name="options">Options for configuring Dapper stores.</param>
public static void AddUserClaimsRecord <TUserClaimsRecord, TUserClaim>(this DapperStoreOptions options)
where TUserClaimsRecord : UserClaimsRecord <string, TUserClaim>
where TUserClaim : IdentityUserClaim <string>, new()
{
options.AddUserClaimsRecord <TUserClaimsRecord, string, TUserClaim>();
}
/// <summary>
/// Add a custom implementation for <see cref="RolesRecord{TRole, TKey, TRoleClaim}" />.
/// </summary>
/// <typeparam name="TRolesRecord">The type of the table to register.</typeparam>
/// <typeparam name="TRole">The type of the class representing a role.</typeparam>
/// <param name="options">Options for configuring Dapper stores.</param>
public static void AddRolesRecord <TRolesRecord, TRole>(this DapperStoreOptions options)
where TRolesRecord : RolesRecord <TRole, string, IdentityRoleClaim <string> >
where TRole : IdentityRole <string>
{
options.AddRolesRecord <TRolesRecord, TRole, string, IdentityRoleClaim <string> >();
}
public MySqlResourceStore(ILogger <MySqlResourceStore> logger, DapperStoreOptions configurationStoreOptions)
{
_logger = logger;
_configurationStoreOptions = configurationStoreOptions;
}
private static void AddStores(IServiceCollection services, Type userType, Type roleType, IDbConnectionFactory dbConnectionFactory,
Action <DapperStoreOptions> configureAction = null)
{
var identityUserType = FindGenericBaseType(userType, typeof(IdentityUser <>));
if (identityUserType == null)
{
throw new InvalidOperationException(
$"Method {nameof(AddDapperStores)} can only be called with a user that derives from IdentityUser<TKey>.");
}
var serviceProvider = services.BuildServiceProvider();
var configuration = serviceProvider.GetRequiredService <IConfiguration>();
var dbConnectionContextOptions = new DapperStoreOptions
{
ConnectionString = configuration.GetConnectionString("DefaultConnection"),
DbConnectionFactory = dbConnectionFactory,
Services = services
};
configureAction?.Invoke(dbConnectionContextOptions);
dbConnectionContextOptions.Services = null;
var keyType = identityUserType.GenericTypeArguments[0];
services.TryAddScoped(typeof(IDbConnectionFactory), x =>
{
var dbConnectionFactoryInstance =
(IDbConnectionFactory)Activator.CreateInstance(dbConnectionContextOptions.DbConnectionFactory
.GetType());
dbConnectionFactoryInstance.ConnectionString = dbConnectionContextOptions.ConnectionString;
return(dbConnectionFactoryInstance);
});
Type userStoreType;
var userClaimType = typeof(IdentityUserClaim <>).MakeGenericType(keyType);
var userRoleType = typeof(IdentityUserRole <>).MakeGenericType(keyType);
var userLoginType = typeof(IdentityUserLogin <>).MakeGenericType(keyType);
var roleClaimType = typeof(IdentityRoleClaim <>).MakeGenericType(keyType);
var userTokenType = typeof(IdentityUserToken <>).MakeGenericType(keyType);
if (roleType != null)
{
var identityRoleType = FindGenericBaseType(roleType, typeof(IdentityRole <>));
if (identityRoleType == null)
{
throw new InvalidOperationException(
$"Method {nameof(AddDapperStores)} can only be called with a role that derives from IdentityRole<TKey>.");
}
services.TryAddScoped(
typeof(IUsersRecord <, , , , ,>).MakeGenericType(userType, keyType, userClaimType, userRoleType,
userLoginType, userTokenType),
typeof(UsersRecord <, , , , ,>).MakeGenericType(userType, keyType, userClaimType, userRoleType,
userLoginType, userTokenType)
);
services.TryAddScoped(typeof(IRolesRecord <, ,>).MakeGenericType(roleType, keyType, roleClaimType),
typeof(RolesRecord <, ,>).MakeGenericType(roleType, keyType, roleClaimType));
services.TryAddScoped(typeof(IUserRolesRecord <, ,>).MakeGenericType(roleType, keyType, userRoleType),
typeof(UserRolesRecord <, ,>).MakeGenericType(roleType, keyType, userRoleType));
services.TryAddScoped(typeof(IRoleClaimsRecord <,>).MakeGenericType(keyType, roleClaimType),
typeof(RoleClaimsRecord <,>).MakeGenericType(keyType, roleClaimType));
services.TryAddScoped(typeof(IRoleStore <>).MakeGenericType(roleType),
typeof(RoleStore <, , ,>).MakeGenericType(roleType, keyType, userRoleType, roleClaimType));
userStoreType = typeof(UserStore <, , , , , , ,>).MakeGenericType(userType, roleType, keyType,
userClaimType, userRoleType, userLoginType, userTokenType, roleClaimType);
}
else
{
services.TryAddScoped(
typeof(IUsersOnlyRecord <, , , ,>).MakeGenericType(userType, keyType, userClaimType, userLoginType,
userTokenType),
typeof(UsersRecord <, , , , ,>).MakeGenericType(userType, keyType, userClaimType, roleType,
userLoginType, userTokenType)
);
userStoreType = typeof(UserOnlyStore <, , , ,>).MakeGenericType(userType, keyType, userClaimType,
userLoginType, userTokenType);
}
services.TryAddScoped(typeof(IUserClaimsRecord <,>).MakeGenericType(keyType, userClaimType),
typeof(UserClaimsRecord <,>).MakeGenericType(keyType, userClaimType));
services.TryAddScoped(typeof(IUserLoginsRecord <, ,>).MakeGenericType(userType, keyType, userLoginType),
typeof(UserLoginsRecord <, ,>).MakeGenericType(userType, keyType, userLoginType));
services.TryAddScoped(typeof(IUserTokensRecord <,>).MakeGenericType(keyType, userTokenType),
typeof(UserTokensRecord <,>).MakeGenericType(keyType, userTokenType));
services.TryAddScoped(typeof(IUserStore <>).MakeGenericType(userType), userStoreType);
}
/// <summary>
/// Add a custom implementation for <see cref="UserTokensRecord{TKey, TUserToken}" />.
/// </summary>
/// <typeparam name="TUserTokensRecord">The type of the table to register.</typeparam>
/// <typeparam name="TUserToken">The type representing a user token.</typeparam>
/// <param name="options">Options for configuring Dapper stores.</param>
public static void AddUserTokensRecord <TUserTokensRecord, TUserToken>(this DapperStoreOptions options)
where TUserTokensRecord : UserTokensRecord <string, TUserToken>
where TUserToken : IdentityUserToken <string>, new()
{
options.AddUserTokensRecord <TUserTokensRecord, string, TUserToken>();
}
private readonly IPersistentGrantSerializer _persistentGrantSerializer; // PersistentGrantSerializer
public DeviceFlowStore(DapperStoreOptions dapperStoreOptions, IPersistentGrantSerializer persistentGrantSerializer)
{
_dapperStoreOptions = dapperStoreOptions;
_persistentGrantSerializer = persistentGrantSerializer;
}
/// <summary>
/// Add a custom implementation for <see cref="RoleClaimsRecord{TKey,TRoleClaim}" />.
/// </summary>
/// <typeparam name="TRoleClaimsRecord">The type of the table to register.</typeparam>
/// <typeparam name="TRoleClaim">The type of the class representing a role claim.</typeparam>
/// <param name="options">Options for configuring Dapper stores.</param>
public static void AddRoleClaimsRecord <TRoleClaimsRecord, TRoleClaim>(this DapperStoreOptions options)
where TRoleClaimsRecord : RoleClaimsRecord <string, TRoleClaim>
where TRoleClaim : IdentityRoleClaim <string>, new()
{
options.AddRoleClaimsRecord <TRoleClaimsRecord, string, TRoleClaim>();
}
public ClientStore(ILogger <ClientStore> logger, DapperStoreOptions configurationStoreOptions)
{
_logger = logger;
_configurationStoreOptions = configurationStoreOptions;
}
public SqlServerPersistedGrants(ILogger <SqlServerPersistedGrants> logger, DapperStoreOptions configurationStoreOptions)
{
_logger = logger;
_configurationStoreOptions = configurationStoreOptions;
}
/// <summary>
/// Add a custom implementation for <see cref="UserRolesRecord{TRole, TKey, TUserRole}" />.
/// </summary>
/// <typeparam name="TUserRolesRecord">The type of the table to register.</typeparam>
/// <typeparam name="TUserRole">The type representing a user role.</typeparam>
/// <param name="options">Options for configuring Dapper stores.</param>
public static void AddUserRolesRecord <TUserRolesRecord, TUserRole>(this DapperStoreOptions options)
where TUserRolesRecord : UserRolesRecord <IdentityRole, string, TUserRole>
where TUserRole : IdentityUserRole <string>, new()
{
options.AddUserRolesRecord <TUserRolesRecord, IdentityRole, string, TUserRole>();
}