/// <summary>
/// 注入数据库服务
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="K"></typeparam>
/// <param name="cissyConfigBuilder"></param>
/// <param name="ConnectionName"></param>
/// <returns></returns>
public static CissyConfigBuilder AddDatabaseConfig <T, K>(this CissyConfigBuilder cissyConfigBuilder, string ConnectionName) where T : DbConnection, new() where K : SqlDialectBase, new()
{
ICissyConfig cissyConfig = cissyConfigBuilder.CissyConfig;
if (cissyConfig.IsNotNull())
{
DatabaseConfig dbConfig = cissyConfig.GetConfig <DatabaseConfig>();
if (dbConfig.IsNotNull())
{
var factory = new DefaultDatabaseFactory <T, K>();
factory.Config = dbConfig;
var dbBuilder = cissyConfigBuilder.ServiceCollection.BuildServiceProvider().GetService <IDBBuilder>();
if (dbBuilder.IsNull())
{
dbBuilder = new DefaultDBBuilder();
cissyConfigBuilder.ServiceCollection.AddSingleton(typeof(IDBBuilder), dbBuilder);
}
DefaultDBBuilder defaultDBBuilder = dbBuilder as DefaultDBBuilder;
if (defaultDBBuilder.IsNotNull())
{
defaultDBBuilder.RegisterDatabaseFactory(ConnectionName, factory);
}
}
}
return(cissyConfigBuilder);
}
public WeiXinAuthBaseController(ICissyConfig cissyConfig)
{
CissyConfig = cissyConfig;
appConfig = CissyConfig.GetConfig <AppConfig>();
Option = Actor.Public.GetService <IAuthenticationOptionBuilder>().Build();
WeiXinMpApi = Actor.Public.GetService <IWeiXinMpApi>();
}
public CissyAuthMiddlerware(RequestDelegate next)
{
_next = next;
this.CissyConfig = Actor.Public.GetService <ICissyConfig>();
this.AppConfig = this.CissyConfig.GetConfig <AppConfig>();
var builder = Actor.Public.GetService <IAuthenticationOptionBuilder>();
Option = builder.Build();
}
/// <summary>
/// 注入Kafka服务
/// </summary>
/// <param name="cissyConfigBuilder"></param>
/// <returns></returns>
public static CissyConfigBuilder AddKafkaConfig(this CissyConfigBuilder cissyConfigBuilder)
{
ICissyConfig cissyConfig = cissyConfigBuilder.CissyConfig;
if (cissyConfig.IsNotNull())
{
KafkaConfig kafkaConfig = cissyConfig.GetConfig <KafkaConfig>();
if (kafkaConfig.IsNotNull())
{
DefaultKafkaFactory factory = new DefaultKafkaFactory();
factory.Config = kafkaConfig;
cissyConfigBuilder.ServiceCollection.AddSingleton(typeof(IKafakaFactory), factory);
}
}
return(cissyConfigBuilder);
}
/// <summary>
/// 注入Redis服务
/// </summary>
/// <param name="cissyConfigBuilder"></param>
/// <returns></returns>
public static CissyConfigBuilder AddElasticsearchConfig(this CissyConfigBuilder cissyConfigBuilder)
{
ICissyConfig cissyConfig = cissyConfigBuilder.CissyConfig;
if (cissyConfig.IsNotNull())
{
ElasticsearchConfig elasticConfig = cissyConfig.GetConfig <ElasticsearchConfig>();
if (elasticConfig.IsNotNull())
{
DefaultElasticsearchFactory factory = new DefaultElasticsearchFactory();
factory.Config = elasticConfig;
cissyConfigBuilder.ServiceCollection.AddSingleton(typeof(IElasticsearchFactory), factory);
}
}
return(cissyConfigBuilder);
}
/// <summary>
/// 注入Redis服务
/// </summary>
/// <param name="cissyConfigBuilder"></param>
/// <returns></returns>
public static CissyConfigBuilder AddRedisConfig(this CissyConfigBuilder cissyConfigBuilder)
{
ICissyConfig cissyConfig = cissyConfigBuilder.CissyConfig;
if (cissyConfig.IsNotNull())
{
RedisConfig redisConfig = cissyConfig.GetConfig <RedisConfig>();
if (redisConfig.IsNotNull())
{
DefaultRedisFactory factory = new DefaultRedisFactory();
factory.Config = redisConfig;
cissyConfigBuilder.ServiceCollection.AddSingleton(typeof(IRedisFactory), factory);
}
}
return(cissyConfigBuilder);
}
/// <summary>
/// 注入AliOSS服务
/// </summary>
/// <param name="cissyConfigBuilder"></param>
/// <returns></returns>
public static CissyConfigBuilder AddAliOSSConfig(this CissyConfigBuilder cissyConfigBuilder)
{
ICissyConfig cissyConfig = cissyConfigBuilder.CissyConfig;
if (cissyConfig.IsNotNull())
{
AliOSSConfig aliOssConfig = cissyConfig.GetConfig <AliOSSConfig>();
if (aliOssConfig.IsNotNull())
{
DefaultAliOSSFactory factory = new DefaultAliOSSFactory();
factory.Config = aliOssConfig;
cissyConfigBuilder.ServiceCollection.AddSingleton(typeof(IAliOSSFactory), factory);
}
}
return(cissyConfigBuilder);
}
/// <summary>
/// 注入kafka常驻内存服务
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cissyConfigBuilder"></param>
/// <returns></returns>
public static CissyConfigBuilder AddKafkaHostService <T>(this CissyConfigBuilder cissyConfigBuilder) where T : KafkaHostService, new()
{
ICissyConfig cissyConfig = cissyConfigBuilder.CissyConfig;
if (cissyConfig.IsNotNull())
{
KafkaConfig kafkaConfig = cissyConfig.GetConfig <KafkaConfig>();
if (kafkaConfig.IsNotNull())
{
DefaultKafkaFactory factory = new DefaultKafkaFactory();
T service = new T();
service.InitService(factory, kafkaConfig);
cissyConfigBuilder.ServiceCollection.AddSingleton(typeof(IHostedService), service);
}
}
return(cissyConfigBuilder);
}
/// <summary>
/// 注入Http代理服务
/// </summary>
/// <param name="cissyConfigBuilder"></param>
/// <returns></returns>
public static CissyConfigBuilder AddHttpProxyConfig(this CissyConfigBuilder cissyConfigBuilder)
{
ICissyConfig cissyConfig = cissyConfigBuilder.CissyConfig;
if (cissyConfig.IsNotNull())
{
HttpProxyConfig httpProxyConfig = cissyConfig.GetConfig <HttpProxyConfig>();
if (httpProxyConfig.IsNotNull())
{
DefaultHttpProxyFactory factory = new DefaultHttpProxyFactory();
factory.Config = httpProxyConfig;
HttpHelper.UseProxy = true;
cissyConfigBuilder.ServiceCollection.AddSingleton(typeof(IHttpProxyFactory), factory);
}
}
return(cissyConfigBuilder);
}
/// <summary>
/// 注入支付服务
/// </summary>
/// <param name="cissyConfigBuilder"></param>
/// <param name="action"></param>
/// <returns></returns>
public static CissyConfigBuilder AddPaymentConfig(this CissyConfigBuilder cissyConfigBuilder)
{
ICissyConfig cissyConfig = cissyConfigBuilder.CissyConfig;
if (cissyConfig.IsNotNull())
{
PaymentConfig payConfig = cissyConfig.GetConfig <PaymentConfig>();
if (payConfig.IsNotNull())
{
var factory = new DefaultPayAppFactory(payConfig);
cissyConfigBuilder.ServiceCollection.AddSingleton(typeof(IPayAppFactory), factory);
}
}
cissyConfigBuilder.RegisterMapper(register =>
{
register.CreateMap <PaymentRequest, PaymentArg>().ForMember(b => b.AppName, n => n.Ignore());
});
return(cissyConfigBuilder);
}
/// <summary>
/// 注入微信公众号Api服务
/// </summary>
/// <param name="cissyConfigBuilder"></param>
/// <returns></returns>
public static CissyConfigBuilder AddWeiXinMpApiConfig(this CissyConfigBuilder cissyConfigBuilder, Func <CissyConfigBuilder, ICache> cacheBuilder)
{
ICissyConfig cissyConfig = cissyConfigBuilder.CissyConfig;
if (cissyConfig.IsNotNull())
{
AppConfig weiXinMpConfig = cissyConfig.GetConfig <AppConfig>();
if (weiXinMpConfig.IsNotNull())
{
if (cacheBuilder.IsNull())
{
throw new NullReferenceException($"cacheBuilder参数为空");
}
Func <ICache> func = () =>
{
return(cacheBuilder(cissyConfigBuilder));
};
var api = new DefaultWeiXinMpApi(weiXinMpConfig, func);
cissyConfigBuilder.ServiceCollection.AddSingleton(typeof(IWeiXinMpApi), api);
}
}
return(cissyConfigBuilder);
}
public WeiXinWebCookieAuthBaseController(ICissyConfig cissyConfig) : base(cissyConfig)
{
}
/// <summary>
/// 注入IS4服务
/// </summary>
/// <param name="cissyConfigBuilder"></param>
/// <param name="WeiXinAuthHandler"></param>
/// <returns></returns>
public static CissyConfigBuilder AddIS4Config(this CissyConfigBuilder cissyConfigBuilder, Func <CissyConfigBuilder, bool> WeiXinAuthHandler = null)
{
JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Clear();
ICissyConfig cissyConfig = cissyConfigBuilder.CissyConfig;
if (cissyConfig.IsNotNull())
{
bool ok = true;
if (WeiXinAuthHandler != default(Func <CissyConfigBuilder, bool>))
{
ok = WeiXinAuthHandler(cissyConfigBuilder);
}
IS4Config is4Config = cissyConfig.GetConfig <IS4Config>();
if (is4Config.IsNotNull())
{
if (ok)
{
var apiBuilder = cissyConfigBuilder.ServiceCollection.AddAuthentication("Bearer");
is4Config.ApiServices.ForEach(m =>
{
apiBuilder.AddJwtBearer(m.Scheme, options =>
{
options.Authority = m.Authority;
options.RequireHttpsMetadata = false;
options.Audience = m.Audience;
});
});
}
is4Config.Cors.ForEach(m =>
{
cissyConfigBuilder.ServiceCollection.AddCors(options =>
{
options.AddPolicy(m.Name, policy =>
{
policy.WithOrigins(m.Origins.ToArray())
.AllowAnyHeader()
.AllowAnyMethod();
});
});
});
if (is4Config.ApiClients.IsNotNullAndEmpty())
{
var builder = cissyConfigBuilder.ServiceCollection.AddAuthentication(options =>
{
options.DefaultScheme = "Cookies";
options.DefaultChallengeScheme = "oidc";
});
builder.AddCookie("Cookies");
is4Config.ApiClients.ForEach(m =>
{
builder.AddOpenIdConnect(m.Scheme, options =>
{
options.SignInScheme = m.SignInScheme;
options.Authority = m.Authority;
options.RequireHttpsMetadata = false;
options.ClientId = m.ClientId;
options.ClientSecret = m.ClientSecret;
options.ResponseType = m.ResponseType;
options.SaveTokens = true;
options.GetClaimsFromUserInfoEndpoint = true;
foreach (string scope in m.Scopes)
{
options.Scope.Add(scope);
}
options.Scope.Add("offline_access");
});
});
}
}
}
return(cissyConfigBuilder);
}
public static CissyConfigBuilder AddCissySwaggerConfig(this CissyConfigBuilder cissyConfigBuilder, Action <SwaggerGenOptions> setupAction = null)
{
ICissyConfig cissyConfig = cissyConfigBuilder.CissyConfig;
if (cissyConfig.IsNotNull())
{
SwaggerConfig swaggerConfig = cissyConfig.GetConfig <SwaggerConfig>();
if (swaggerConfig.IsNotNull())
{
_waggerConfig = swaggerConfig;
cissyConfigBuilder.ServiceCollection.AddSwaggerGen(c =>
{
List <OpenApiTag> tags = new List <OpenApiTag>();
foreach (SwaggerVersionConfig version in swaggerConfig.Versions)
{
c.SwaggerDoc(version.Version, new OpenApiInfo
{
Version = version.Version,
Title = version.Title,
Description = version.Description,
TermsOfService = version.TermsOfService.IsNotNullAndEmpty() ? new Uri(version.TermsOfService) : default(Uri)
});
}
c.DocInclusionPredicate((docName, apiDesc) =>
{
if (!apiDesc.TryGetMethodInfo(out MethodInfo methodInfo))
{
return(false);
}
var versions = methodInfo.DeclaringType
.GetCustomAttributes(true)
.OfType <CissyApiAttribute>();
bool ok = versions.Any(v => v.GroupName.IsNullOrEmpty() || v.GroupName == docName);
if (ok)
{
foreach (CissyApiAttribute caa in versions)
{
if (caa.Description.IsNotNullAndEmpty())
{
var name = methodInfo.DeclaringType.Name;
var lname = name.ToLower();
string ctn = "controller";
if (lname.EndsWith(ctn))
{
name = name.Substring(0, name.Length - ctn.Length);
}
tags.Add(new OpenApiTag()
{
Name = name,
Description = caa.Description
});
}
}
}
return(ok);
});
DefaultControllerTagDescriptions.SetTags(tags);
c.DocumentFilter <DefaultControllerTagDescriptions>();
setupAction?.Invoke(c);
});
}
}
return(cissyConfigBuilder);
}
public WeiXinMpJwtAuthBaseController(ICissyConfig cissyConfig) : base(cissyConfig)
{
}
static void UseWeiXin <T>(this CissyConfigBuilder cissyConfigBuilder, string AuthenticationScheme, bool isJwt, WeiXinAppType appType) where T : IWeiXinAuthController
{
JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Clear();
ICissyConfig cissyConfig = cissyConfigBuilder.CissyConfig;
if (cissyConfig.IsNotNull())
{
WeiXinMpConfig wxConfig = cissyConfig.GetConfig <WeiXinMpConfig>();
if (wxConfig.IsNotNull())
{
string controllerName = typeof(T).Name.ToLower();
string c = "controller";
if (controllerName.EndsWith(c))
{
controllerName = controllerName.Substring(0, controllerName.Length - c.Length);
}
cissyConfigBuilder.ServiceCollection.AddAuthentication(AuthenticationScheme)
.AddCookie(AuthenticationScheme, options =>
{
if (appType == WeiXinAppType.WXA)
{
options.AccessDeniedPath = Actor.Public.GetWXALoginPath(controllerName, AuthenticationScheme);
options.LoginPath = Actor.Public.GetWXALoginPath(controllerName, AuthenticationScheme);
}
if (appType == WeiXinAppType.Mp)
{
options.AccessDeniedPath = Actor.Public.GetMpLoginPath(controllerName, AuthenticationScheme);
options.LoginPath = Actor.Public.GetMpLoginPath(controllerName, AuthenticationScheme);
}
else if (appType == WeiXinAppType.Web)
{
options.AccessDeniedPath = Actor.Public.GetWebLoginPath(controllerName, AuthenticationScheme);
options.LoginPath = Actor.Public.GetWebLoginPath(controllerName, AuthenticationScheme);
}
options.Cookie.HttpOnly = true;
});
if (isJwt)
{
cissyConfigBuilder.ServiceCollection.AddAuthentication(options =>
{
options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
//options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
//options.DefaultSignInScheme = JwtBearerDefaults.AuthenticationScheme;
//options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(x =>
{
x.RequireHttpsMetadata = false;
x.SaveToken = true;
x.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Convert.FromBase64String(wxConfig.JwtSecret)),
ValidateIssuer = false,
ValidateAudience = false
};
});
}
}
}
}
public WeiXinAppAuthBaseController(ICissyConfig cissyConfig, IWeiXinMpApi weiXinMpApi)
{
CissyConfig = cissyConfig;
this.WeiXinMpApi = weiXinMpApi;
WeiXinMpConfig = CissyConfig.GetConfig <WeiXinMpConfig>();
}
public WeiXinWebAuthBaseController(ICissyConfig cissyConfig)
{
CissyConfig = cissyConfig;
WeiXinMpConfig = CissyConfig.GetConfig <WeiXinMpConfig>();
}
