public static IApplicationBuilder ConfigureRestApi(
this IApplicationBuilder app,
IWebHostEnvironment env,
RestApiOptions restApiOptions)
{
return(app.ConfigureRestApi(env, restApiOptions, _ => { }));
}
public AllowAnonymousAccessForDevelopmentHandler(
IWebHostEnvironment environment,
RestApiOptions apiOptions)
{
this.environment = environment ?? throw new ArgumentNullException(nameof(environment));
this.apiOptions = apiOptions ?? throw new ArgumentNullException(nameof(apiOptions));
}
public Startup(IConfiguration configuration)
{
Configuration = configuration;
restApiOptions = new RestApiOptions
{
AllowAnonymousAccessForDevelopment = true,
UseApplicationInsights = true,
UseAutoRegistrateServices = true,
UseEnumAsStringInSerialization = true,
UseHttpContextAccessor = true,
ErrorHandlingExceptionFilter = new RestApiOptionsErrorHandlingExceptionFilter
{
Enable = true,
UseProblemDetailsAsResponseBody = true,
IncludeExceptionDetails = true,
},
UseRequireHttpsPermanent = true,
UseJsonSerializerOptionsIgnoreNullValues = true,
JsonSerializerCasingStyle = CasingStyle.CamelCase,
UseValidateServiceRegistrations = true,
};
restApiOptions.AddAssemblyPairs(
Assembly.GetAssembly(typeof(ApiRegistration)),
Assembly.GetAssembly(typeof(DomainRegistration)));
}
private static void HandleAssemblyPairs(IServiceCollection services, RestApiOptions restApiOptions)
{
if (restApiOptions == null)
{
throw new ArgumentNullException(nameof(restApiOptions));
}
if (restApiOptions.AssemblyPairs.Count == 0)
{
return;
}
if (restApiOptions.UseAutoRegistrateServices)
{
foreach (var assemblyPairOptions in restApiOptions.AssemblyPairs)
{
services.AutoRegistrateServices(
assemblyPairOptions.ApiAssembly,
assemblyPairOptions.DomainAssembly);
}
}
if (!restApiOptions.UseValidateServiceRegistrations)
{
return;
}
foreach (var assemblyPairOptions in restApiOptions.AssemblyPairs)
{
services.ValidateServiceRegistrations(assemblyPairOptions.ApiAssembly);
}
}
public SolumeReposity(IOptions <MongoDbOptions> mongoSettings,
IOptions <RestApiOptions> restApiOptions,
IJsonDeserialize jsonDeserialize)
{
_restApiOptions = restApiOptions.Value;
_jsonDeserialize = jsonDeserialize;
_context = new CoinTweetyDbContext(mongoSettings);
}
public ErrorHandlingExceptionFilterAttribute(
TelemetryClient telemetryClient,
RestApiOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
this.telemetryClient = telemetryClient;
includeException = options.ErrorHandlingExceptionFilter.IncludeExceptionDetails;
useProblemDetailsAsResponseBody = options.ErrorHandlingExceptionFilter.UseProblemDetailsAsResponseBody;
}
public static RhetosAspNetServiceCollectionBuilder AddRestApi(this RhetosAspNetServiceCollectionBuilder builder,
Action <RestApiOptions> configureOptions, Action <ControllerRestInfoRepository> onControllerRestInfoCreated = null)
{
var options = new RestApiOptions()
{
BaseRoute = "RhetosRestApi",
ConceptInfoRestMetadataProviders = new List <IConceptInfoRestMetadataProvider>(_defaultMetadataProviders)
};
configureOptions?.Invoke(options);
builder.Services.TryAddScoped <QueryParameters>();
builder.Services.TryAddScoped <ServiceUtility>();
builder.Services.TryAddScoped <JsonErrorHandler>();
builder.Services.TryAddScoped <ApiExceptionFilter>();
builder.Services.TryAddScoped <ApiCommitOnSuccessFilter>();
var controllerRepository = CreateControllerRestInfoRepository(builder.RhetosHost, options);
onControllerRestInfoCreated?.Invoke(controllerRepository);
builder.Services.AddSingleton(controllerRepository);
builder.Services
.AddControllers(o =>
{
o.Conventions.Add(new RestApiControllerRouteConvention(options, controllerRepository));
})
.ConfigureApplicationPartManager(p =>
{
p.FeatureProviders.Add(new RestApiControllerFeatureProvider(controllerRepository));
});
return(builder);
}
private static ControllerRestInfoRepository CreateControllerRestInfoRepository(RhetosHost rhetosHost, RestApiOptions options)
{
var controllerRepository = new ControllerRestInfoRepository();
foreach (var conceptInfoRestMetadataProvider in options.ConceptInfoRestMetadataProviders)
{
var metadataFromProvider = conceptInfoRestMetadataProvider.GetConceptInfoRestMetadata(rhetosHost);
foreach (var metadataItem in metadataFromProvider)
{
controllerRepository.ControllerConceptInfo.Add(metadataItem.ControllerType, metadataItem);
}
}
// transform all group names
if (options.GroupNameMapper != null)
{
foreach (var restMetadata in controllerRepository.ControllerConceptInfo.Values)
{
restMetadata.ApiExplorerGroupName = options.GroupNameMapper.Invoke(restMetadata.ConceptInfo, restMetadata.ApiExplorerGroupName);
}
}
return(controllerRepository);
}
public TwitterAccountReposity(IOptions <RestApiOptions> restApiOptions, IJsonDeserialize jsonDeserialize)
{
_jsonDeserialize = jsonDeserialize;
_restApiOptions = restApiOptions.Value;
}
public Startup(IConfiguration configuration)
{
_configuration = configuration;
_jwtOptions = GetJwtOptions();
_restApiOptions = GetRestApiOptions();
}
public SocialStatsReposity(IJsonDeserialize jsonDeserialize, IOptions <RestApiOptions> restApiOptions)
{
_jsonDeserialize = jsonDeserialize;
_restApiOptions = restApiOptions.Value;
}
public static IApplicationBuilder ConfigureRestApi(
this IApplicationBuilder app,
IWebHostEnvironment env,
RestApiOptions restApiOptions,
Action <IApplicationBuilder> setupAction)
{
if (app == null)
{
throw new ArgumentNullException(nameof(app));
}
if (env == null)
{
throw new ArgumentNullException(nameof(env));
}
if (restApiOptions == null)
{
throw new ArgumentNullException(nameof(restApiOptions));
}
if (setupAction == null)
{
throw new ArgumentNullException(nameof(setupAction));
}
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
setupAction(app);
app.UseCors(options =>
{
options.AllowAnyHeader();
options.AllowAnyMethod();
options.AllowAnyOrigin();
});
app.UseMiddleware <KeepAliveMiddleware>();
app.UseMiddleware <RequestCorrelationMiddleware>();
app.UseMiddleware <ExceptionTelemetryMiddleware>();
if (!env.IsDevelopment())
{
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles(new StaticFileOptions
{
OnPrepareResponse = ctx =>
{
ctx.Context.Response.Headers.Append("Access-Control-Allow-Origin", "*");
},
});
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapApiSpecificationEndpoint(restApiOptions.AssemblyPairs);
endpoints.MapControllers();
});
return(app);
}
public static IServiceCollection AddRestApi <TStartup>(
this IServiceCollection services,
Action <IMvcBuilder> setupMvcAction,
RestApiOptions restApiOptions)
{
if (setupMvcAction == null)
{
throw new ArgumentNullException(nameof(setupMvcAction));
}
if (restApiOptions == null)
{
throw new ArgumentNullException(nameof(restApiOptions));
}
if (restApiOptions.UseHttpContextAccessor)
{
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddTransient <IRequestContext, RequestContext>();
}
services.ConfigureOptions <ConfigureApiBehaviorOptions>();
if (restApiOptions.UseApplicationInsights)
{
services.AddApplicationInsightsTelemetry();
services.AddCallingIdentityTelemetryInitializer();
}
HandleAssemblyPairs(services, restApiOptions);
var mvc = services
.AddControllers(mvcOptions =>
{
if (restApiOptions.ErrorHandlingExceptionFilter.Enable)
{
mvcOptions.Filters.Add(
new ErrorHandlingExceptionFilterAttribute(
restApiOptions.ErrorHandlingExceptionFilter.IncludeExceptionDetails,
restApiOptions.ErrorHandlingExceptionFilter.UseProblemDetailsAsResponseBody));
}
mvcOptions.OutputFormatters.RemoveType <StringOutputFormatter>();
mvcOptions.RequireHttpsPermanent = restApiOptions.UseRequireHttpsPermanent;
})
.AddJsonOptions(jsonOptions =>
{
switch (restApiOptions.JsonSerializerCasingStyle)
{
case CasingStyle.CamelCase:
jsonOptions.JsonSerializerOptions.DictionaryKeyPolicy = JsonNamingPolicy.CamelCase;
jsonOptions.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
break;
case CasingStyle.PascalCase:
jsonOptions.JsonSerializerOptions.DictionaryKeyPolicy = null;
jsonOptions.JsonSerializerOptions.PropertyNamingPolicy = null;
break;
default:
throw new SwitchCaseDefaultException(restApiOptions.JsonSerializerCasingStyle);
}
jsonOptions.JsonSerializerOptions.IgnoreNullValues = restApiOptions.UseJsonSerializerOptionsIgnoreNullValues;
jsonOptions.JsonSerializerOptions.WriteIndented = false;
jsonOptions.JsonSerializerOptions.AllowTrailingCommas = false;
if (restApiOptions.UseEnumAsStringInSerialization)
{
jsonOptions.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
}
});
services.AddSingleton(restApiOptions);
services.AddAnonymousAccessForDevelopment();
setupMvcAction(mvc);
return(services);
}
public static IServiceCollection AddRestApi <TStartup>(
this IServiceCollection services,
RestApiOptions restApiOptions)
{
return(services.AddRestApi <TStartup>(mvc => { }, restApiOptions));
}
