public void Configuration(IAppBuilder appBuilder, Action<ContainerBuilder> action)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.ColoredConsole()
.WriteTo.TextWriter(new StreamWriter(@"SampleProject.Provider.log"))
.CreateLogger();
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config
.EnableSwagger(c => c.SingleApiVersion("v1", "Sample Provider"))
.EnableSwaggerUi();
var container = GetContainer(action);
config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
appBuilder
.Use(typeof(LoggingMiddleware))
.UseAutofacWebApi(config)
.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var builder = new ContainerBuilder();
builder.RegisterInstance(GetDbExecutor(ConnectionString)).As<IDbExecutor>();
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
builder.RegisterType<SqlServerRepository>().As<IFeatureToggleRepository>().SingleInstance();
builder.RegisterType<FeatureToggleValidator>().As<IFeatureToggleValidator>().SingleInstance();
var container = builder.Build();
app.UseCors(CorsOptions.AllowAll);
app.UseAutofacMiddleware(container);
var config = new HttpConfiguration();
config.EnableSwagger(c => c.SingleApiVersion("v1", "Feature Toggle Service API"))
.EnableSwaggerUi();
config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
config.Formatters.Remove(config.Formatters.XmlFormatter);
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Services.Replace(typeof(IExceptionHandler), new UnhandledErrorService());
app.Use(typeof(AuditMiddlware));
app.UseWebApi(config);
}
private static void ConfigureSwagger(HttpConfiguration config)
{
config.EnableSwagger(
c => c.SingleApiVersion("v1", "IconKeeper").Description("Icon Keeper Web Api"))
.EnableSwaggerUi(
c => c.CustomAsset("index", typeof(Startup).Assembly, "IconKeeper.Server.WebApi.Swagger.index.html"));
}
/// <summary>
/// Initializes Swagger Documentation
/// </summary>
/// <param name="httpConfig"></param>
private static void InitialiseSwagger(HttpConfiguration httpConfig)
{
try
{
httpConfig
.EnableSwagger(c =>
{
c.SingleApiVersion("v1", "fIT Api");
c.IncludeXmlComments(GetXmlPath());
c.IgnoreObsoleteActions();
c.DescribeAllEnumsAsStrings();
c.OAuth2("oauth2")
.Description("OAuth2 Password Grant")
.Flow("password")
//.AuthorizationUrl("http://petstore.swagger.wordnik.com/api/oauth/dialog")
.TokenUrl("/Accounts/Login")
.Scopes(scopes =>
{
scopes.Add("user", "Read access to protected resources");
scopes.Add("admin", "Write access to protected resources");
});
})
.EnableSwaggerUi(c =>
{
c.InjectJavaScript(typeof(Startup).Assembly, "fIT.WebApi/js/onComplete.js");
});
}
catch (Exception e)
{
throw new Exception("Error on creating Swagger: " + e.Message + Environment.NewLine + e.StackTrace);
}
}
public static HttpConfiguration ConfigureHttpConfig(this IAppBuilder appBuilder, HttpConfiguration config, Action<SwaggerDocsConfig> unitTestConfigs, params Type[] targetControllers)
{
var server = new HttpServer(config);
appBuilder.UseWebApi(server);
config.EnableSwagger(c =>
{
// Use "SingleApiVersion" to describe a single version API. Swagger 2.0 includes an "Info" object to
// hold additional metadata for an API. Version and title are required but you can also provide
// additional fields by chaining methods off SingleApiVersion.
//
c.SingleApiVersion("v1", "A title for your API");
// Wrap the default SwaggerGenerator with additional behavior (e.g. caching) or provide an
// alternative implementation for ISwaggerProvider with the CustomProvider option.
//
c.CustomProvider(defaultProvider => new ODataSwaggerProvider(defaultProvider, c, config));
// Apply test-specific configs
unitTestConfigs?.Invoke(c);
}).EnableSwaggerUi();
FormatterConfig.Register(config);
config.Services.Replace(typeof (IHttpControllerSelector), new UnitTestControllerSelector(config, targetControllers));
return config;
}
public void Configuration(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
//See info about OWIN in https://github.com/domaindrivendev/Swashbuckle
//Manually enable the Swagger docs and, optionally, the swagger-ui by invoking the
//extension methods (in namespace Swashbuckle.Application) on an instance of HttpConfiguration in Startup.cs
config
.EnableSwagger(c =>
{
c.SingleApiVersion("v1", "MyHealth.MobileApp");
// Set filter to eliminate duplicate operation ids from being generated
// when there are multiple operations with the same verb in the API.
c.OperationFilter<IncludeParameterNamesInOperationIdFilter>();
// Set another filter to eliminate duplciation operation ids from being generated
// when there are multiple Web API routes, like /tables and /api
c.OperationFilter<IncludeRouteNameInOperationIdFilter>();
}
)
.EnableSwaggerUi();
new MobileAppConfiguration()
.UseDefaultConfiguration()
.ApplyTo(config);
app.UseWebApi(config);
}
public static void Register(HttpConfiguration config, AutofacWebApiDependencyResolver resolver)
{
config.EnableEnumPrefixFree(enumPrefixFree: true);
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.DependencyResolver = resolver;
ConfigureFormatters(config);
config.EnableSwagger("docs/{apiVersion}/", c =>
{
var baseDirectory = AppDomain.CurrentDomain.BaseDirectory + @"bin\";
var commentsFileName = Assembly.GetExecutingAssembly().GetName().Name + ".XML";
var commentsFile = Path.Combine(baseDirectory, commentsFileName);
c.IncludeXmlComments(commentsFile);
c.DescribeAllEnumsAsStrings();
c.SingleApiVersion("v1", "TaskCat Core Api");
}).EnableSwaggerUi();
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
config.EnableSwagger("help/{apiVersion}", c =>
{
c.IncludeXmlComments("Slight.WeMo.Service.XML");
c.SingleApiVersion("v1", "Slight.WeMo REST Api");
}).EnableSwaggerUi("help/ui/{*assetPath}");
app.UseWebApi(config);
GlobalConfiguration.Configuration.UseMemoryStorage();
app.UseHangfireDashboard("/hangfire", new DashboardOptions
{
AuthorizationFilters = new IAuthorizationFilter[] { new AllowAllFilter() }
});
app.UseHangfireServer();
app.Use(async (context, func) =>
{
if (new[] { "/", "/help" }.Any(x => context.Request.Path.Value.StartsWith(x)))
{
context.Response.Redirect("/help/ui/index");
return;
}
await func.Invoke();
});
}
private static HttpConfiguration GetWebApiConfig(IAppBuilder appBuilder)
{
Metric.Config
.WithHttpEndpoint("http://localhost:9999/metrics/")
.WithReporting(r => r.WithConsoleReport(TimeSpan.FromSeconds(30)));
//.WithOwin(middleware => appBuilder.Use(middleware), x => x
// .WithRequestMetricsConfig(c => c.WithAllOwinMetrics())
// .WithMetricsEndpoint());
//.WithInternalMetrics()
// .WithAllCounters();
var config = new HttpConfiguration();
config.Formatters.Add(new JsonHalMediaTypeFormatter(BuildHypermediaConfiguration()));
config
.EnableSwagger(c =>
{
c.SingleApiVersion("v1", "A title for your API");
c.IncludeXmlComments("OwinSelfHost.XML");
})
.EnableSwaggerUi();
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "ActionApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
return config;
}
/// <summary>
/// Registers the configuration.
/// </summary>
/// <param name="config">The http configuration</param>
public static void Register(HttpConfiguration config)
{
config
.EnableSwagger(c =>
{
// assembly comments
var baseDirectory = AppDomain.CurrentDomain.BaseDirectory + "\\Bin";
c.IncludeXmlComments(Path.Combine(baseDirectory, "AngularSkeleton.Web.Application.xml"));
c.IncludeXmlComments(Path.Combine(baseDirectory, "AngularSkeleton.Service.Model.xml"));
// information
c.SingleApiVersion("v1", "AngularSkeleton.NET")
.Description("AngularSkeleton application API")
.TermsOfService("MIT License")
.Contact(cc => cc
.Name("Christopher Town")
.Url("https://github.com/christophla/AngularSkeleton.NET"))
.License(lc => lc
.Name("License")
.Url("https://github.com/christophla/AngularSkeleton.NET/blob/master/LICENSE"));
// authorization
c
.OAuth2("oauth2")
.Description("Resource owner password credentials grant")
.Flow("password")
.AuthorizationUrl("http://localhost:54391/api/rest/v1/accesstoken");
})
.EnableSwaggerUi("api/rest/docs/{*assetPath}");
}
public static void Register(HttpConfiguration configuration)
{
var serviceVersion = string.Empty;
configuration.EnableSwagger(
c =>
{
c.SingleApiVersion(string.IsNullOrEmpty(serviceVersion) ? "1" : serviceVersion, "Concept Search API")
.Description("Save drawing and share on social medias")
.Contact(cc => cc
.Name("DrawPub Team")
.Email("*****@*****.**"))
.License(lc => lc
.Name("DrawPub License"));
c.RootUrl(req => new Uri(req.RequestUri, req.GetRequestContext().VirtualPathRoot).ToString());
c.ResolveConflictingActions(apiDescriptions => apiDescriptions.First());
c.IgnoreObsoleteActions();
c.IncludeXmlComments(GetXmlCommentsPath());
})
.EnableSwaggerUi(
c =>
{
c.EnableDiscoveryUrlSelector();
c.DocExpansion(DocExpansion.None);
c.EnableOAuth2Support("client_id", "realm", "Swagger UI");
});
}
public void Configuration(IAppBuilder app)
{
// SignalR - real-time io.
app.MapSignalR();
// Setting the camel case resolver for web api below does not cause camel case to be invoked for signalr
// or other serialization events. This enforces camel case through all serialization.
GlobalHost.DependencyResolver.Register(typeof(JsonSerializer), () => JsonSerializerFactory.Value);
// Configure Web API.
HttpConfiguration config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Formatters.Remove(config.Formatters.XmlFormatter);
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.MessageHandlers.Add(new NoCacheHeaderHandler());
app.UseWebApi(config);
// Swagger API publishing.
config.EnableSwagger(c => c.SingleApiVersion("v1", "Mouselight Acquisition Acquisition API")).EnableSwaggerUi();
MonitorManager.SharedManager.HostApplicationVersion = String.Format("v{0}", typeof(Startup).Assembly.GetName().Version);
}
public void Configuration(IAppBuilder appBuilder)
{
HttpConfiguration config = new HttpConfiguration();
try
{
config
.EnableSwagger(c =>
{
c.RootUrl(req =>
{
return req.RequestUri.GetLeftPart(UriPartial.Authority) + "/dartshooting";
});
c.SingleApiVersion("v1", "A title for your API");
})
.EnableSwaggerUi(
);
config.EnableCors();
config.MapHttpAttributeRoutes();
RouteConfig.RegisterRoutes(config.Routes);
appBuilder.UseWebApi(config);
}
catch (Exception e)
{
Trace.WriteLine(e);
}
}
public static void ConfigureSwagger(HttpConfiguration config)
{
// Use the custom ApiExplorer that applies constraints. This prevents
// duplicate routes on /api and /tables from showing in the Swagger doc.
config.Services.Replace(typeof(IApiExplorer), new MobileAppApiExplorer(config));
config
.EnableSwagger(c =>
{
c.SingleApiVersion("v1", "myService");
// Tells the Swagger doc that any MobileAppController needs a
// ZUMO-API-VERSION header with default 2.0.0
c.OperationFilter<MobileAppHeaderFilter>();
// Looks at attributes on properties to decide whether they are readOnly.
// Right now, this only applies to the DatabaseGeneratedAttribute.
c.SchemaFilter<MobileAppSchemaFilter>();
// 1. Adds an OAuth implicit flow description that points to App Service Auth with the specified provdier
// 2. Adds a Swashbuckle filter that applies this Oauth description to any Action with [Authorize]
c.AppServiceAuthentication("https://{mysite}.azurewebsites.net/", "{provider}");
})
.EnableSwaggerUi(c =>
{
c.EnableOAuth2Support("na", "na", "na");
// Replaces some javascript files with specific logic to:
// 1. Do the OAuth flow using the App Service Auth parameters
// 2. Parse the returned token
// 3. Apply the token to the X-ZUMO-AUTH header
c.MobileAppUi();
});
}
public void Configuration(IAppBuilder app)
{
ConfigureAuth(app);
//SwaggerConfig.Register();
HttpConfiguration httpConfiguration = new HttpConfiguration();
httpConfiguration.EnableSwagger(c => c.SingleApiVersion("v1", "A title for your API")).EnableSwaggerUi();
httpConfiguration.EnsureInitialized();
}
public void Configuration(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
config
.EnableSwagger(c => c.SingleApiVersion("v1", "Pirate Stream API"))
.EnableSwaggerUi();
WebApiConfig.Register(config);
}
public static void SetupSwagger(HttpConfiguration config)
{
Contract.Requires(config != null);
var swaggerConfiguration = config.EnableSwagger(SetupSwaggerConfig);
Contract.Assume(swaggerConfiguration != null);
swaggerConfiguration.EnableSwaggerUi();
}
/// <summary>
/// Load the httpConfiguration
/// </summary>
/// <param name="config"></param>
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Configure Web API to use only bearer token authentication.
//config.SuppressDefaultHostAuthentication();
//config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
// Use camel case for JSON data and remove XML support
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver =
new CamelCasePropertyNamesContractResolver();
config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(
new StringEnumConverter { CamelCaseText = true });
config.Formatters.Remove(config.Formatters.XmlFormatter);
// Enables CORS
config.EnableCors(new EnableCorsAttribute("*", "*", "*"));
// Set dependency injection
SetAutofacContainer(config);
// Exception handler
config.Services.Replace(typeof(IExceptionHandler), new AuluxaExceptionHandler());
// Web API routes
config.MapHttpAttributeRoutes();
// Swagger
config.EnableSwagger(c =>
{
// Manage title and versioning
c.SingleApiVersion("v1", ConfigurationManager.AppSettings["ServiceName"]);
// Automatically gets the generated XML doc of the controllers and inject them in swagger
string baseDirectory = AppDomain.CurrentDomain.RelativeSearchPath ?? AppDomain.CurrentDomain.BaseDirectory;
// Include XmlComments
string commentFileName = $"{Assembly.GetExecutingAssembly().GetName().Name}.XML";
c.IncludeXmlComments(Path.Combine(baseDirectory, commentFileName));
})
.EnableSwaggerUi("help/{*assetPath}", c =>
{
// Inject auth URL as 'realm'. Could do better
c.EnableOAuth2Support(
"web",
"nosecret",
ConfigurationManager.AppSettings["auluxa-auth:Url"],
"auluxa-auth");
// Deactivate validator
c.DisableValidator();
// Inject login form javascript
c.InjectJavaScript(Assembly.GetExecutingAssembly(), "Auluxa.WebApp.onComplete.js");
});
// Ensure initialization is correct
config.EnsureInitialized();
}
/// <summary>
/// Register Config Variables
/// </summary>
/// <param name="config"></param>
public static void Register (HttpConfiguration config)
{
//--------------------------------------------------------------------------------------------------------------------------------------------
// Web API routes
config.EnableGaleRoutes("v1"); // If you want manual versioning, don't send the api version
config.EnableSwagger();
config.SetJsonDefaultFormatter(); //Google Chrome Fix (default formatter is xml :/)
//--------------------------------------------------------------------------------------------------------------------------------------------
}
protected override void EnableSwagger(HttpConfiguration config)
{
base.EnableSwagger(config);
// configure swagger as well on separate URL
config
.EnableSwagger("docs/{apiVersion}/.metadata", c => c.SingleApiVersion("v1", "A title for your API"))
.EnableSwaggerUi("docs-ui/{*assetPath}");
}
private void ConfigureSwagger( IAppBuilder app, HttpConfiguration config )
{
config.EnableSwagger(c =>
{
c.SingleApiVersion("v1", "Web API Swagger Doc")
.Description("Web API documentation generated by swashbuckle/swagger");
})
.EnableSwaggerUi();
}
/// <summary>
/// Register Config Variables
/// </summary>
/// <param name="config"></param>
public static void Register (HttpConfiguration config)
{
//--------------------------------------------------------------------------------------------------------------------------------------------
// Web API routes
config.EnableGaleRoutes();
config.EnableSwagger();
config.SetJsonDefaultFormatter(); //Google Chrome Fix (default formatter is xml :/)
//--------------------------------------------------------------------------------------------------------------------------------------------
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
WebApiConfig.Register(config);
config.EnableSwagger(c => c.SingleApiVersion("v1", "BigFoodieMealsAPI"))
.EnableSwaggerUi();
app.UseNinjectMiddleware(NinjectKernal.CreateKernel).UseNinjectWebApi(config);
}
internal static void Register(HttpConfiguration config)
{
config
.EnableSwagger(c =>
{
c.SingleApiVersion("v1", "AppCampus PortalApi");
c.IncludeXmlComments(GetXmlCommentsPath());
})
.EnableSwaggerUi();
}
/// <summary>
/// Adds the Swagger UI to the RESTful application.
/// </summary>
/// <param name="config">The OWIN config.</param>
private static void AddSwaggerSupport(HttpConfiguration config)
{
config.EnableSwagger(c =>
{
var settingsProvider = IoCProvider.Resolve<ISettingsProvider>();
c.SingleApiVersion("v1", settingsProvider.Title)
.Description(settingsProvider.Description);
c.IncludeXmlComments($@"{System.AppDomain.CurrentDomain.BaseDirectory}\Api.xml");
}).EnableSwaggerUi();
}
public static void Register(HttpConfiguration config)
{
config
.EnableSwagger(c =>
{
c.RootUrl(req => req.RequestUri.GetLeftPart(UriPartial.Authority) +
req.GetRequestContext().VirtualPathRoot.TrimEnd('/'));
c.SingleApiVersion("v1", "myProducts Web API");
})
.EnableSwaggerUi();
}
private static void ConfigureSwagger(HttpConfiguration config)
{
config.EnableSwagger(
c =>
{
c.SingleApiVersion("v1", "WebApiSkeleton")
.Description("WebApi Skeleton");
c.IncludeXmlComments(GetXmlCommentsPathForControllers());
})
.EnableSwaggerUi();
}
/// <summary>
///
/// </summary>
/// <param name="config"></param>
public static void Register(HttpConfiguration config)
{
config
.EnableSwagger(c =>
{
c.SingleApiVersion("v2", "FriendFinder");
c.RootUrl(GetBasePath);
c.IncludeXmlComments(GetXmlCommentsPath());
})
.EnableSwaggerUi();
}
public void Configuration(IAppBuilder appBuilder)
{
HttpConfiguration httpConfiguration = new HttpConfiguration();
WebApiConfig.Register(httpConfiguration);
httpConfiguration
.EnableSwagger(c => c.SingleApiVersion("v1", "Customer API"))
.EnableSwaggerUi();
appBuilder.UseWebApi(httpConfiguration);
}
public void Configuration(IAppBuilder app)
{
var httpConfiguration = new HttpConfiguration();
// Configure Swagger UI
httpConfiguration
.EnableSwagger(c => c.SingleApiVersion("v1", "A title for your API"))
.EnableSwaggerUi();
// Configure Web API Routes:
// - Enable Attribute Mapping
// - Enable Default routes at /api.
httpConfiguration.MapHttpAttributeRoutes();
httpConfiguration.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
app.UseWebApi(httpConfiguration);
// Make ./public the default root of the static files in our Web Application.
app.UseFileServer(new FileServerOptions
{
RequestPath = new PathString(string.Empty),
FileSystem = new PhysicalFileSystem("./"),
EnableDirectoryBrowsing = true,
});
app.UseStageMarker(PipelineStage.MapHandler);
}
