static void ImportToIdentityServer(MicroserviceOptions MSOptions)
{
if (MSOptions.IdentityServerUri == null)
{
return;
}
var url = $"{MSOptions.IdentityServerUri.OriginalString}/api/ApiResource/Import";
using (var hc = new HttpClient())
{
var content = new StringContent(JsonConvert.SerializeObject(new
{
MSOptions.MicroServiceName,
MSOptions.MicroServiceDisplayName,
MSOptions.MicroServiceDescription,
MSOptions.MicroServiceClientIDs,
MSOptions.MicroServiceRedirectUrls,
MicroServicePolicies = MicroserviceExtensions.EntryAssemblyPolicies()
}), Encoding.UTF8, "application/json");
try
{
var response = hc.PostAsync(url, content).Result;
}
catch {
}
}
}
public Startup(IConfiguration configuration)
{
Configuration = configuration;
_microserviceOptions = new MicroserviceOptions <ApiMicroserviceOptions>()
{
ServiceId = "web-1",
};
_microservice = new ApiMicroservice(_microserviceOptions);
}
public static void UseMicroservice(this IApplicationBuilder app, IHostingEnvironment env,
MicroserviceOptions microserviceOptions)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseAuthentication();
CultureInfo[] supportedCultures = new[]
{
"de-DE",
"en-US"
}.Select(code => new CultureInfo(code)).ToArray();
app.UseRequestLocalization(new RequestLocalizationOptions
{
DefaultRequestCulture = new RequestCulture("en-US"),
// Formatting numbers, dates, etc.
SupportedCultures = supportedCultures,
// UI strings that we have localized.
SupportedUICultures = supportedCultures
});
app.UseCors(options => options
.AllowAnyOrigin()
.AllowAnyHeader()
.AllowAnyMethod()
.WithExposedHeaders("X-Authentication-Hash")
.AllowCredentials());
app.UseResponseCompression();
JsonExceptionMiddleware jsonExceptionMiddleware =
new JsonExceptionMiddleware(app.ApplicationServices.GetRequiredService <IHostingEnvironment>());
app.UseExceptionHandler(new ExceptionHandlerOptions {
ExceptionHandler = jsonExceptionMiddleware.Invoke
});
app.UseSwagger();
app.UseSwaggerUI(options =>
{
options.SwaggerEndpoint("/swagger/1.0/swagger.json", microserviceOptions.Swagger.Title);
options.DocExpansion(DocExpansion.List);
});
app.Use(async(context, next) =>
{
CurrentUserProvider currentUserProvider = app.ApplicationServices.GetService <CurrentUserProvider>();
if (currentUserProvider != null)
{
context.Response.Headers.Add("X-Authentication-Hash", currentUserProvider.User.Name.ToSha256());
}
await next();
});
app.UseMvcWithDefaultRoute();
}
/// <summary>
/// Creates a builder.
/// </summary>
/// <param name="services">The services.</param>
/// <param name="configuration">The config.</param>
/// <returns></returns>
public static IMicroserviceBuilder AddMicroService(
this IServiceCollection services,
IConfiguration configuration,
Action <MicroserviceOptions> msOptions = null)
{
var Options = new MicroserviceOptions();
if (msOptions != null)
{
msOptions.Invoke(Options);
}
var MSConfig = configuration.GetSection("MicroService").Get <MicroserviceConfig>();
#region MicroServiceName
if (string.IsNullOrWhiteSpace(Options.MicroServiceName))
{
Options.MicroServiceName = MSConfig.Name;
if (string.IsNullOrWhiteSpace(Options.MicroServiceName))
{
Options.MicroServiceName = AppConstant.AssemblyName.ToLower();
throw new Exception("Not config MicroServiceName");
}
}
#endregion
#region MicroServiceDisplayName
if (string.IsNullOrWhiteSpace(Options.MicroServiceDisplayName))
{
Options.MicroServiceDisplayName = MSConfig.DisplayName;
if (string.IsNullOrWhiteSpace(Options.MicroServiceDisplayName))
{
Options.MicroServiceDisplayName = Options.MicroServiceName;
}
}
#endregion
#region MicroServiceDescription
if (string.IsNullOrWhiteSpace(Options.MicroServiceDescription))
{
Options.MicroServiceDescription = MSConfig.Description;
if (string.IsNullOrWhiteSpace(Options.MicroServiceDescription))
{
Options.MicroServiceDescription = Options.MicroServiceName;
}
}
#endregion
#region MicroServiceClientIDs
if (Options.MicroServiceClientIDs.Count < 1)
{
Options.MicroServiceClientIDs = MSConfig.ClientIDs;
if (Options.MicroServiceClientIDs.Count < 1)
{
Options.MicroServiceClientIDs = new List <string>()
{
"swagger"
};
}
}
#endregion
#region MicroServiceRedirectUrls
if (Options.MicroServiceRedirectUrls.Count < 1)
{
Options.MicroServiceRedirectUrls = MSConfig.RedirectUrls;
if (Options.MicroServiceRedirectUrls.Count < 1)
{
throw new Exception("please config MicroService:RedirectUrls in appsettings.json");
}
}
#endregion
var builder = new MicroserviceBuilder(services);
builder.Services.AddSingleton(Options);
#region Cors
if (Options.EnableCors)
{
builder.Services.AddCors(options =>
{
options.AddPolicy("cors-allowanonymous", x =>
{
x.AllowAnyHeader();
x.AllowAnyMethod();
x.AllowAnyOrigin();
x.AllowCredentials();
});
});
}
#endregion
#region WebEncoders
if (Options.EnableWebEncoders)
{
services.AddWebEncoders(opt =>
{
opt.TextEncoderSettings = new TextEncoderSettings(UnicodeRanges.All);
});
}
#endregion
#region AuthorizationPolicy
if (Options.EnableAuthorizationPolicy)
{
builder.Services.AddAuthorization(options =>
{
var entry_policies = EntryAssemblyPolicies();
foreach (var policyConfig in entry_policies)
{
#region Client的权限策略
policyConfig.Scopes.ForEach(x =>
{
var policyName = $"{PolicyKey.ClientScope}:{x}";
var policyValues = new List <string>()
{
$"{Options.MicroServiceName}.{x}",
$"{Options.MicroServiceName}.{policyConfig.ControllerName}.all",
$"{Options.MicroServiceName}.all"
};
options.AddPolicy(policyName,
policy => policy.RequireClaim(PolicyKey.ClientScope, policyValues));
});
#endregion
#region User的权限策略
policyConfig.Permissions.ForEach(x =>
{
var policyName = $"{PolicyKey.UserPermission}:{x}";
var policyValues = new List <string>()
{
$"{Options.MicroServiceName}.{x}",
$"{Options.MicroServiceName}.{policyConfig.ControllerName}.all",
$"{Options.MicroServiceName}.all"
};
options.AddPolicy(policyName,
policy => policy.RequireAssertion(handler =>
{
var claim = handler.User.Claims
.FirstOrDefault(c => c.Type.Equals(PolicyKey.UserPermission));
if (claim != null && !string.IsNullOrWhiteSpace(claim.Value))
{
var claimValues = claim.Value.ToLower().Split(new string[] { "," },
StringSplitOptions.RemoveEmptyEntries);
if (claimValues != null && claimValues.Length > 0)
{
foreach (var item in claimValues)
{
if (policyValues.Contains(item))
{
return(true);
}
}
}
}
return(false);
}));
});
#endregion
}
});
}
#endregion
#region SwaggerGen
if (Options.EnableSwaggerGen)
{
services.AddSwaggerGen(c =>
{
c.EnableAnnotations();
//c.TagActionsBy(x => x.RelativePath.Split('/')[0]);
c.AddSecurityDefinition("SubscriptionKey",
new ApiKeyScheme()
{
Name = "Ocp-Apim-Subscription-Key",
Type = "apiKey",
In = "header",
Description = "从开放平台申请的Subscription Key，从网关调用接口时必需传入。",
});
c.AddSecurityDefinition("AccessToken",
new ApiKeyScheme()
{
Name = "Authorization",
Type = "apiKey",
In = "header",
Description = "从身份认证中心颁发的Token，根据接口要求决定是否传入。",
});
if (Options.IdentityServerUri != null)
{
c.AddSecurityDefinition("OAuth2",
new OAuth2Scheme()
{
Type = "oauth2",
Flow = "accessCode",
AuthorizationUrl = Options.IdentityServerUri.OriginalString + "/connect/authorize",
TokenUrl = Options.IdentityServerUri.OriginalString + "/connect/token",
Description = "勾选授权范围，获取Token",
Scopes = new Dictionary <string, string>()
{
{ "openid", "用户标识" },
{ "profile", "用户资料" },
{ Options.MicroServiceName + ".all", "所有接口权限" },
}
});
}
var provider = services.BuildServiceProvider()
.GetRequiredService <IApiVersionDescriptionProvider>();
foreach (var description in provider.ApiVersionDescriptions)
{
c.SwaggerDoc(description.GroupName, new Info
{
Title = AppConstant.AssemblyName,
Version = description.ApiVersion.ToString(),
License = new License()
{
Name = "MIT",
Url = "https://spdx.org/licenses/MIT.html"
},
// Contact = new Contact()
// {
// Url = "",
// Name = "",
// Email = ""
// },
// Description = "Swagger document",
});
c.CustomSchemaIds(x => x.FullName);
}
var SiteSwaggerFilePath = Path.Combine(PlatformServices.Default.Application.ApplicationBasePath,
AppConstant.AssemblyName + ".xml");
if (File.Exists(SiteSwaggerFilePath))
{
c.IncludeXmlComments(SiteSwaggerFilePath);
}
});
}
#endregion
#region Localization
if (Options.EnableLocalization)
{
builder.Services.AddLocalization(options => options.ResourcesPath = "Resources");
services.Configure <RequestLocalizationOptions>(options =>
{
var supportedCultures = new[]
{
new CultureInfo("en-US"),
new CultureInfo("zh-CN"),
};
options.DefaultRequestCulture = new RequestCulture("zh-CN", "zh-CN");
options.SupportedCultures = supportedCultures;
options.SupportedUICultures = supportedCultures;
});
builder.Services.AddMvc()
.AddViewLocalization(LanguageViewLocationExpanderFormat.Suffix)
.AddDataAnnotationsLocalization()
.AddJsonOptions(o =>
{
o.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
o.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
});
}
#endregion
#region ApiVersioning
if (Options.EnableApiVersioning)
{
builder.Services.AddVersionedApiExplorer(o => o.GroupNameFormat = "'v'VVV");
builder.Services.AddApiVersioning(o =>
{
o.AssumeDefaultVersionWhenUnspecified = true;
o.ReportApiVersions = true;
});
}
#endregion
#region Authentication
builder.Services.AddAuthentication(IdentityServerAuthenticationDefaults.AuthenticationScheme)
.AddIdentityServerAuthentication(isAuth =>
{
isAuth.Authority = Options.IdentityServerUri.OriginalString;
isAuth.ApiName = Options.MicroServiceName;
isAuth.RequireHttpsMetadata = true;
});
#endregion
#region ResponseCaching
if (Options.EnableResponseCaching)
{
builder.Services.AddResponseCaching();
}
#endregion
return(builder);
}
// ReSharper disable once UnusedMember.Global
public void Configure(IApplicationBuilder app, IHostingEnvironment env, MicroserviceOptions microserviceOptions)
{
app.UseMicroservice(env, microserviceOptions);
}
public static IServiceProvider AddMicroservice(this IServiceCollection services, IConfiguration configuration,
MicroserviceOptions microserviceOptions)
{
services.AddOptions();
services.Configure <SendGridOptions>(configuration.GetSection("SendGrid"));
services.Configure <ApplicationSettings>(configuration.GetSection("Application"));
services.Configure <DatabaseOptions>(options =>
options.ConnectionString = microserviceOptions.Database.ConnectionString);
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(options =>
{
options.Authority = microserviceOptions.Authentication.Authority;
options.Audience = microserviceOptions.Authentication.Audience;
});
services.AddMvc()
.AddJsonOptions(options =>
{
options.SerializerSettings.Converters.Add(new StringEnumConverter());
options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
})
.AddControllersAsServices()
.AddViewLocalization(LanguageViewLocationExpanderFormat.Suffix)
.AddFluentValidation();
services.AddLocalization(options => options.ResourcesPath = "Resources");
services.AddApiVersioning(options =>
{
options.ReportApiVersions = true;
options.AssumeDefaultVersionWhenUnspecified = true;
options.DefaultApiVersion = new ApiVersion(1, 0);
});
services.AddSwaggerGen(options =>
{
options.SwaggerDoc(microserviceOptions.Swagger.Version, new Info
{
Title = microserviceOptions.Swagger.Title,
Version = microserviceOptions.Swagger.Version
});
options.AddSecurityDefinition("Bearer", new ApiKeyScheme
{
Description =
"JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\"",
Name = "Authorization",
In = "header",
Type = "apiKey"
});
options.AddSecurityRequirement(new Dictionary <string, IEnumerable <string> >
{
{
"Bearer", new string[] { }
}
});
});
services.Configure <GzipCompressionProviderOptions>(options => options.Level = CompressionLevel.Optimal);
services.AddCors();
services.AddResponseCompression(options => { options.EnableForHttps = true; });
ContainerBuilder builder = new ContainerBuilder();
builder.RegisterInstance(microserviceOptions)
.AsSelf()
.SingleInstance();
builder.RegisterType <HttpContextAccessor>()
.As <IHttpContextAccessor>()
.InstancePerLifetimeScope();
builder.RegisterType <CurrentUserProvider>()
.AsSelf()
.InstancePerLifetimeScope();
builder.Register(context =>
{
CurrentUserProvider provider = context.Resolve <CurrentUserProvider>();
return(provider.User);
})
.AsSelf()
.InstancePerDependency();
builder.RegisterType <RazorViewRenderer>()
.As <IViewRenderer>()
.InstancePerLifetimeScope();
builder.Register(context =>
{
IOptions <SendGridOptions> options = context.Resolve <IOptions <SendGridOptions> >();
return(new SendGridClient(options.Value));
})
.As <IEmailClient>()
.InstancePerLifetimeScope();
builder.RegisterModule(new Mapping(microserviceOptions.DomainAssemblies.Select(Assembly.Load)));
builder.RegisterModule(new Validation(microserviceOptions.DomainAssemblies.Select(Assembly.Load)));
builder.Populate(services);
IContainer container = EventFlowOptions.New
.UseAutofacContainerBuilder(builder)
.ConfigureEntityFramework(EntityFrameworkConfiguration.New)
.ConfigureDomain(microserviceOptions.DomainRegistration)
.CreateContainer();
return(container.Resolve <IServiceProvider>());
}
