public void Configuration(IAppBuilder appBuilder)
{
// Configure Web API for self-host.
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
appBuilder.UseWebApi(config);
var appFolder = Path.Combine(Directory.GetParent(AppDomain.CurrentDomain.BaseDirectory).Parent.Parent.FullName, "Webportal");
appBuilder.UseFileServer(new Microsoft.Owin.StaticFiles.FileServerOptions
{
RequestPath = new PathString(WebPortalUrl),
FileSystem = new PhysicalFileSystem(appFolder),
EnableDirectoryBrowsing = true
});
appBuilder.Map(PathString.Empty, a => a.Use<PortalRedirectionMiddelware>(WebPortalUrl));
appBuilder.Use<AdminMiddleware>();
}
public void Configuration(IAppBuilder appBuilder)
{
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new {id = RouteParameter.Optional});
appBuilder.UseWebApi(config).UseNancy();
}
// This code configures Web API. The Startup class is specified as a type
// parameter in the WebApp.Start method.
public void Configuration(IAppBuilder appBuilder)
{
// Configure Web API for self-host.
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// 默认返回Json数据
//config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
//var bson = new BsonMediaTypeFormatter();
//bson.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/bson"));
//config.Formatters.Add(bson);
config.Formatters.Add(new Raven.AspNet.WebApiExtensions.Formatters.MsgPackFormatter());
appBuilder.UseRequestScopeContext();
appBuilder.UseWebApi(config);
//CallContext
//appBuilder.Use(
}
public void Configuration(IAppBuilder app)
{
app.UseIdentityServerBearerTokenAuthentication(
new IdentityServerBearerTokenAuthenticationOptions
{
Authority = ExpenseTrackerConstants.IdSrv,
RequiredScopes = new[] { "expensetrackerapi" }
});
app.UseWebApi(WebApiConfig.Register());
app.UseWebApi(WebApiConfig.Register());
}
public void Configuration(IAppBuilder app)
{
ConfigureWebApi();
ConfigureJsonFormatter();
app.UseWebApi(_configuration);
}
public void Configuration(IAppBuilder app)
{
JwtSecurityTokenHandler.InboundClaimTypeMap.Clear();
app.UseIdentityServerBearerTokenAuthentication(new IdentityServerBearerTokenAuthenticationOptions
{
Authority = "https://localhost:44333/core",
RequiredScopes = new[] { "api" },
NameClaimType = "name",
RoleClaimType = "role",
// client credentials for the introspection endpoint
ClientId = "angularMaterial",
ClientSecret = Guid.NewGuid().ToString()
});
var configuration = new HttpConfiguration();
configuration.MapHttpAttributeRoutes();
var jsonFormatter = configuration.Formatters.OfType<JsonMediaTypeFormatter>().FirstOrDefault();
if (jsonFormatter != null)
{
jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
}
app.UseResourceAuthorization(new AuthorizationManager());
app.UseWebApi(configuration);
app.UseNancy();
app.UseStageMarker(PipelineStage.MapHandler);
}
public void Configuration(IAppBuilder app)
{
var httpConfiguration = new HttpConfiguration();
// 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("./public"),
EnableDirectoryBrowsing = true,
});
app.UseStageMarker(PipelineStage.MapHandler);
}
public void Configuration(IAppBuilder app)
{
var webApiConfiguration = ConfigureWebApi();
webApiConfiguration.EnsureInitialized();
app.UseWebApi(webApiConfiguration);
ConfigureHandlers();
}
public void Configuration(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
new MobileAppConfiguration()
.UseDefaultConfiguration()
.ApplyTo(config);
app.UseWebApi(config);
MobileAppSettingsDictionary settings = config.GetMobileAppSettingsProvider().GetMobileAppSettings();
if (string.IsNullOrEmpty(settings.HostName))
{
app.UseAppServiceAuthentication(new AppServiceAuthenticationOptions
{
// This middleware is intended to be used locally for debugging. By default, HostName will
// only have a value when running in an App Service application.
SigningKey = ConfigurationManager.AppSettings["SigningKey"],
ValidAudiences = new[] { ConfigurationManager.AppSettings["ValidAudience"] },
ValidIssuers = new[] { ConfigurationManager.AppSettings["ValidIssuer"] },
TokenHandler = config.GetAppServiceTokenHandler()
});
}
}
public static void Configure(IAppBuilder app)
{
if (app == null)
throw new ArgumentNullException("app");
IContainer container = IocConfiguration.BuildContainer(actorSystemName: "Wakka");
app.UseAutofacMiddleware(container);
HttpConfiguration webApiConfiguration = new HttpConfiguration
{
// Only used when mapping attribute routes.
DependencyResolver = new AutofacWebApiDependencyResolver(container)
};
app.UseAutofacWebApi(webApiConfiguration); // Share OWIN lifetime scope.
webApiConfiguration.MapHttpAttributeRoutes();
webApiConfiguration.EnsureInitialized();
app.UseWebApi(webApiConfiguration);
// Explicitly start the actor system when the OWIN app is started.
ActorSystem actorSystem = container.ResolveNamed<ActorSystem>("Wakka");
// Try to gracefully shut down the actor system when the host is shutting down.
AppProperties appProperties = new AppProperties(app.Properties);
appProperties.OnAppDisposing.Register(() =>
{
actorSystem.Shutdown();
actorSystem.AwaitTermination(
timeout: TimeSpan.FromSeconds(5)
);
});
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
ConfigureOAuth(app);
WebApiConfig.Register(config);
app.UseWebApi(config);
}
public static void ConfigureMobileApp(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
#if DEBUG
config.Formatters.JsonFormatter.SerializerSettings.Formatting = Formatting.Indented;
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
#endif
new MobileAppConfiguration().UseDefaultConfiguration().ApplyTo(config);
config.Services.Add(typeof(IExceptionLogger), new AiExceptionLogger());
// Use Entity Framework Code First to create database tables based on your DbContext
Database.SetInitializer(new MobileServiceInitializer());
MobileAppSettingsDictionary settings = config.GetMobileAppSettingsProvider().GetMobileAppSettings();
if (string.IsNullOrEmpty(settings.HostName))
{
app.UseAppServiceAuthentication(new AppServiceAuthenticationOptions
{
// This middleware is intended to be used locally for debugging. By default, HostName will
// only have a value when running in an App Service application.
SigningKey = ConfigurationManager.AppSettings["SigningKey"],
ValidAudiences = new[] { ConfigurationManager.AppSettings["ValidAudience"] },
ValidIssuers = new[] { ConfigurationManager.AppSettings["ValidIssuer"] },
TokenHandler = config.GetAppServiceTokenHandler()
});
}
app.UseWebApi(config);
}
public static void Configuration(IAppBuilder builder)
{
HttpConfiguration configuration = new HttpConfiguration();
configuration.Routes.MapODataServiceRoute("odata", null, GetEdmModel())
.MapODataRouteAttributes(configuration); // Enable attribute routing.
builder.UseWebApi(configuration);
}
public void Configuration(IAppBuilder app)
{
SecurityConfig.Config();
var oauthServerConfig = new Microsoft.Owin.Security.OAuth.OAuthAuthorizationServerOptions
{
AllowInsecureHttp = false,
AccessTokenExpireTimeSpan = TimeSpan.FromHours(2),
Provider = new AuthorizationServerProvider(),
TokenEndpointPath = new PathString("/token")
};
app.UseOAuthAuthorizationServer(oauthServerConfig);
var oauthConfig = new Microsoft.Owin.Security.OAuth.OAuthBearerAuthenticationOptions
{
AuthenticationMode = Microsoft.Owin.Security.AuthenticationMode.Active
//AuthenticationType = "Bearer"
};
app.UseOAuthBearerAuthentication(oauthConfig);
var config = new HttpConfiguration();
WebApiConfig.Register(config);
app.UseWebApi(config);
GlobalHost.Configuration.ConnectionTimeout = TimeSpan.FromSeconds(1);
GlobalHost.Configuration.LongPollDelay = TimeSpan.FromMilliseconds(5000);
app.MapSignalR();
}
public static void ConfigureMobileApp(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
config.EnableCors(new EnableCorsAttribute("*", "*", "*", "*"));
config.MapHttpAttributeRoutes();
config.EnableSystemDiagnosticsTracing();
config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
new MobileAppConfiguration()
.UseDefaultConfiguration()
.ApplyTo(config);
Database.SetInitializer(new ContosoMomentsDBInitializer());
ConfigureStorage();
// set up auth for local development
//app.UseAppServiceAuthentication(new AppServiceAuthenticationOptions() {
// SigningKey = ConfigurationManager.AppSettings["authSigningKey"],
// ValidAudiences = new[] { ConfigurationManager.AppSettings["authAudience"] },
// ValidIssuers = new[] { ConfigurationManager.AppSettings["authIssuer"] },
// TokenHandler = config.GetAppServiceTokenHandler()
//});
// Increases the HTTP Connection Pool.
ServicePointManager.DefaultConnectionLimit = 100;
app.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional });
// Remove XML formatter
var json = config.Formatters.JsonFormatter;
json.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.None;
config.Formatters.Remove(config.Formatters.XmlFormatter);
// NetIn and assign a dependency resolver for Web API to use.
var dependencyResolver = new DependencyResolver();
config.DependencyResolver = dependencyResolver;
// Filter for loggering
var logActionFilter = new Containerizer.Filters.LogActionFilter(DependencyResolver.logger);
config.Filters.Add(logActionFilter);
var exceptionLoggingFilter = new Containerizer.Filters.ExceptionLoggingFilter(DependencyResolver.logger);
config.Filters.Add(exceptionLoggingFilter);
// Make sure the Autofac lifetime scope is passed to Web API.
app.UseAutofacWebApi(config);
app.MapWebSocketPattern<ContainerProcessHandler>("/api/containers/(?<handle>.*)/run", dependencyResolver);
app.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute("Api", "{Controller}");
config.EnableCors();
var issuer = ConfigurationManager.AppSettings["Issuer"];
var audience = ConfigurationManager.AppSettings["Audience"];
var signingCertificateSubjectDistinguishedName = ConfigurationManager.AppSettings["SigningCertificateSubjectDistinguishedName"];
var store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadOnly);
var certificate = store.Certificates.Find(X509FindType.FindBySubjectDistinguishedName, signingCertificateSubjectDistinguishedName, true)[0];
// JSON should serialize to camelCase, not PascalCase (the default)
var jsonFormatter = config.Formatters.OfType<JsonMediaTypeFormatter>().First();
jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
// Api controllers with an [Authorize] attribute will be validated with JWT
app.UseJwtBearerAuthentication(
new JwtBearerAuthenticationOptions
{
AuthenticationMode = AuthenticationMode.Active,
AllowedAudiences = new[] {audience},
IssuerSecurityTokenProviders = new IIssuerSecurityTokenProvider[]
{
new X509CertificateSecurityTokenProvider(issuer, certificate),
//new X509CertificateSecurityTokenProvider(issuer, new X509Certificate2("PATH_TO_YOUR_PUBLIC_CERTIFICATE.cer")),
},
});
app.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
// initialize cors
app.UseCors(CorsOptions.AllowAll);
// initialize authentication
app.UseCookieAuthentication(new CookieAuthenticationOptions()
{
AuthenticationType = CookieAuthenticationDefaults.AuthenticationType,
AuthenticationMode = AuthenticationMode.Active,
ExpireTimeSpan = TimeSpan.FromHours(1),
SlidingExpiration = true
});
// initialize webapi
HttpConfiguration config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "Default",
routeTemplate: "{controller}/{id}",
defaults: new
{
id = RouteParameter.Optional
});
// initialize dependency injection
ConfigureDependencies(app, config);
// bind web api
app.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
// Before configuring the API, first initialize the database
InitializeRavenDB();
// Build the configuration for Web API
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
// Ensure no browser-side caching is used
config.Filters.Add(new NoCacheHeaderFilter());
// Make JSON the default format
var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
// Use camel-casing for property names
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
// Serialize enums using their string value
config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new StringEnumConverter());
// Be flexible with additional data, for backwards compatability purposes
config.Formatters.JsonFormatter.SerializerSettings.MissingMemberHandling = MissingMemberHandling.Ignore;
// Share the formatter settings with the manager
FeatureManager.JsonSerializerSettings = config.Formatters.JsonFormatter.SerializerSettings;
// Make sure that Web API is enabled for our application
app.UseWebApi(config);
// Set the error detail policy to match the asp.net configuration
SetErrorDetailPolicy(config);
}
// This code configures Web API contained in the class Startup, which is additionally specified as the type
// parameter in WebApplication.Start
public void Configuration(IAppBuilder appBuilder)
{
// Add SimpeInjector package.
var container = new Container();
container.Options.DefaultScopedLifestyle = new WebApiRequestLifestyle();
// Add SimpleInjector.Integration.WebApi package.
container.Register<IValuesService, ValuesService>(new WebApiRequestLifestyle());
// Configure Web API for Self-Host
// HttpConfiguration located in Microsoft.AspNet.WebApi.Core package.
HttpConfiguration config = new HttpConfiguration();
// Add System.Web reference to avoid "Missing ..." error.
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
// UseWebApi extension method located in Microsoft.AspNet.WebApi.OwinSelfHost package.
appBuilder.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
HttpConfiguration httpConfiguration = new HttpConfiguration();
WebApiConfig.Register(httpConfiguration);
app.UseWebApi(httpConfiguration);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
config.Routes.MapHttpRoute(
"DefaultApi", "api/{controller}/{id}", new {id = RouteParameter.Optional});
var builder = new ContainerBuilder();
// Register Web API controller in executing assembly.
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
// Register a logger service to be used by the controller and middleware.
builder.Register(c => new Logger()).As<ILogger>().InstancePerRequest();
// Autofac will add middleware to IAppBuilder in the order registered.
// The middleware will execute in the order added to IAppBuilder.
builder.RegisterType<FirstMiddleware>().InstancePerRequest();
builder.RegisterType<SecondMiddleware>().InstancePerRequest();
var container = builder.Build();
// Create and assign a dependency resolver for Web API to use.
config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
// This should be the first middleware added to the IAppBuilder.
app.UseAutofacMiddleware(container);
// Make sure the Autofac lifetime scope is passed to Web API.
app.UseAutofacWebApi(config);
app.UseWebApi(config);
}
// This code configures Web API. The Startup class is specified as a type
// parameter in the WebApp.Start method.
public void Configuration(IAppBuilder appBuilder)
{
// Configure Web API for self-host.
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
appBuilder.UseWebApi(config);
}
// Invoked once at startup to configure your application.
public void Configuration(IAppBuilder builder)
{
var config = new HttpConfiguration();
// Create the container as usual.
var container = new Container();
// Register your types, for instance using the RegisterWebApiRequest
// extension from the integration package:
container.RegisterWebApiRequest<IUserRepository, SqlUserRepository>();
// This is an extension method from the integration package.
container.RegisterWebApiControllers(config);
container.Verify();
config.DependencyResolver =
new SimpleInjectorWebApiDependencyResolver(container);
config.MapHttpAttributeRoutes();
//config.Routes.MapHttpRoute("Default", "", new { controller = "OEmbed" });
//config.Formatters.XmlFormatter.UseXmlSerializer = true;
//config.Formatters.Remove(config.Formatters.JsonFormatter);
////config.Formatters.Remove(config.Formatters.XmlFormatter);
// config.Formatters.JsonFormatter.UseDataContractJsonSerializer = true;
builder.UseWebApi(config);
//builder.Use(async (context, next) => {
// using (container.BeginExecutionContextScope())
// {
// await next();
// }
//});
}
public void Configuration(IAppBuilder app)
{
var httpConfiguration = new HttpConfiguration();
// 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 }
);
httpConfiguration.Formatters.Clear();
httpConfiguration.Formatters.Add(new JsonMediaTypeFormatter());
httpConfiguration.Formatters.JsonFormatter.SerializerSettings =
new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
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);
}
private static void UseWebApi(IAppBuilder application, IKernel kernel)
{
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
var cors = new EnableCorsAttribute("*", "*", "*");
//GlobalConfiguration.Configure(configuration =>
//{
// configuration.SuppressDefaultHostAuthentication();
// configuration.MapHttpAttributeRoutes();
// configuration.EnableCors(cors);
// configuration.Filters.Add(new HostAuthenticationAttribute(OAuthDefaults.AuthenticationType));
// var jsonformatter = configuration.Formatters.JsonFormatter;
// jsonformatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
// configuration.AddJsonpFormatter();
// application.UseNinjectMiddleware(() => kernel);
// application.UseNinjectWebApi(configuration);
// application.UseWebApi(configuration);
//});
config.SuppressDefaultHostAuthentication();
ConfigureOAuth(application);
config.EnableCors(cors);
config.Filters.Add(new HostAuthenticationAttribute(OAuthDefaults.AuthenticationType));
var jsonformatter = config.Formatters.JsonFormatter;
jsonformatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.AddJsonpFormatter();
application.UseNinjectMiddleware(() => kernel);
application.UseNinjectWebApi(config);
application.UseWebApi(config);
application.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
OAuthOptions = new OAuthAuthorizationServerOptions
{
TokenEndpointPath = new PathString("/Token"),
Provider = new ApplicationOAuthProvider(),
AuthorizeEndpointPath = new PathString("/api/Account/ExternalLogin"),
AccessTokenExpireTimeSpan = TimeSpan.FromDays(14),
// Note: Remove the following line before you deploy to production:
AllowInsecureHttp = true
};
// Enable the application to use bearer tokens to authenticate users
app.UseOAuthBearerTokens(OAuthOptions);
app.UseWebApi(config);
}
// This method is required by Katana:
public void Configuration(IAppBuilder app)
{
var webApiConfiguration = ConfigureWebApi();
app.UseCors(CorsOptions.AllowAll);
app.UseWebApi(webApiConfiguration);
}
public void Configuration(IAppBuilder appBuilder)
{
Log.Info("Causal Server startup");
UpgradeDatabase();
System.Data.Entity.Database.SetInitializer(
new NullDatabaseInitializer<CausalContext>());
var config = new HttpConfiguration();
config.Routes.MapHttpRoute(
name: "SiteMap",
routeTemplate: "",
defaults: new { controller = "SiteMap" });
config.Routes.MapHttpRoute(
name: "Product",
routeTemplate: "1/product/{id}",
defaults: new { controller = "Product", id = RouteParameter.Optional });
config.Routes.MapHttpRoute(
name: "Ping",
routeTemplate: "1/ping",
defaults: new { controller = "Ping" });
appBuilder.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
// token consumption
app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());
var container = SimpleInjectorConfig.Register();
var config = new HttpConfiguration
{
DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container)
};
WebApiConfig.Register(config);
app.UseWebApi(config);
Func<IUserService> userServiceFactory = () => container.GetInstance<IUserService>();
app.UseOAuthAuthorizationServer(new OAuthAuthorizationServerOptions
{
// for demo purposes
AllowInsecureHttp = true,
TokenEndpointPath = new PathString("/token"),
AccessTokenExpireTimeSpan = TimeSpan.FromHours(8),
Provider = new AuthorizationServerProvider(userServiceFactory)
});
}
public void Configuration(IAppBuilder app)
{
OAuthAuthorizationServerOptions oAuthOption =
new OAuthAuthorizationServerOptions()
{
Provider = new MyOAuthProvider(),
AccessTokenExpireTimeSpan = TimeSpan.FromDays(1),
TokenEndpointPath = new PathString("/mytoken"),
AllowInsecureHttp = true,
};
app.UseOAuthAuthorizationServer(oAuthOption);
app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());
HttpConfiguration confg = new HttpConfiguration();
WebApiConfig.Register(confg);
app.UseWebApi(confg);
}
public void Configuration(IAppBuilder appBuilder)
{
Linq2DbMap.Map();
MapperRegistrar.Register();
var httpConfiguration = GlobalConfiguration.Configuration;
IoCRegistrar.Register(httpConfiguration);
httpConfiguration.Filters.Add(new DefaultExceptionFilterAttribute());
GlobalConfiguration.Configure(WebApiConfig.Register);
httpConfiguration.EnsureInitialized();
httpConfiguration
.EnableSwagger(c => c.SingleApiVersion("v1", "Category Viewer"))
.EnableSwaggerUi();
appBuilder.UseWebApi(httpConfiguration);
}
public void Configuration(IAppBuilder app)
{
//OAuthAuthorizationServerOptions OAuthServerOptions = new OAuthAuthorizationServerOptions()
//{
// AllowInsecureHttp = true,
// TokenEndpointPath = new PathString("/login"),
// AccessTokenExpireTimeSpan = TimeSpan.FromDays(1),
// Provider = new AuthorizationServer(),
// RefreshTokenProvider = new RefreshTokenProvider()
//};
// Token Generation
//app.UseOAuthAuthorizationServer(OAuthServerOptions);
//app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());
HttpConfiguration config = new HttpConfiguration();
WebApiConfig.Register(config);
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
app.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
// accept access tokens from identityserver and require a scope of 'api1'
app.UseIdentityServerBearerTokenAuthentication(new IdentityServerBearerTokenAuthenticationOptions
{
Authority = "http://localhost:5000",
ValidationMode = ValidationMode.ValidationEndpoint,
RequiredScopes = new[] { "api1" }
});
// configure web api
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
// require authentication for all controllers
//config.Filters.Add(new AuthorizeAttribute());
app.UseWebApi(config);
}
public void Configuration(IAppBuilder builder)
{
// Configure Web API for self-host.
var config = new HttpConfiguration();
//todo: need to assign IoC resolver
config.Routes.MapHttpRoute(
name: "TimeSpanApi",
routeTemplate: "api/{controller}/{timeSpan}",
defaults: new { timeSpan = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "CountApi",
routeTemplate: "api/{controller}/{count}/{level}",
defaults: new { count = RouteParameter.Optional, level = RouteParameter.Optional }
);
builder.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
Authorization.Configure(app, new AuthApplicationService());
HttpConfiguration config = new HttpConfiguration();
config.SuppressDefaultHostAuthentication();
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
config.Formatters.Remove(config.Formatters.XmlFormatter);
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(name: "ApiRoute", routeTemplate: "{controller}/{id}", defaults: new { id = RouteParameter.Optional });
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
config.EnableCors();
config.Filters.Add(new ExceptionInterceptor());
config.Filters.Add(new AuthorizeAttribute());
app.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
app.UseIdentityServerBearerTokenAuthentication(new IdentityServerBearerTokenAuthenticationOptions
{
Authority = "http://localhost:5000",
RequiredScopes = new[] { "api" },
DelayLoadMetadata = true
});
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
app.UseWebApi(config);
}
// This code configures Web API. The Startup class is specified as a type
// parameter in the WebApp.Start method.
public void Configuration(IAppBuilder appBuilder)
{
// Configure Web API for self-host.
HttpConfiguration config = new HttpConfiguration();
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
config.Routes.MapHttpRoute(
"API Default", "api/{controller}/{id}",
new
{
id = RouteParameter.Optional,
controller = "HelloWorld"
}
);
appBuilder.UseWebApi(config);
}
public void Configuration(IAppBuilder appBuilder)
{
var autofacResolver = AutofacConfig.ConfigureContainer().Build();
var config = new HttpConfiguration();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Filters.Add(new ValidateModelAttribute());
config.MessageHandlers.Add(new LogRequestAndResponseHandler());
config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new AccountRequestConverterConfig());
config.DependencyResolver = new AutofacWebApiDependencyResolver(autofacResolver);
config.Services.Replace(typeof(IExceptionLogger), new ExceptionLoggerConfig());
config.Services.Replace(typeof(IExceptionHandler), new GlobalExceptionHandlerConfig());
appBuilder.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
config.Routes.MapHttpRoute(
"Default",
"api/{controller}/{id}",
new { id = RouteParameter.Optional });
GlobalHost.HubPipeline.AddModule(new ErrorHandlingPipelineModule());
GlobalHost.HubPipeline.AddModule(new LoggingPipelineModule());
app.MapSignalR("/hubs", new HubConfiguration {
EnableDetailedErrors = true
});
app.ConfigureDependencies(config)
.ConfigureAuth();
app.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
app.UseCors(CorsOptions.AllowAll);
AtivarGeracaoTokens(app);
app.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
/*Configuracion del log4net:*/
log4net.Config.XmlConfigurator.Configure();
var log = log4net.LogManager.GetLogger(typeof(Startup));
log.Debug("Loggin habilitado");
var config = new HttpConfiguration();
config.Services.Replace(typeof(IExceptionHandler), new GlobalExceptionHandler());
DIConfig.ConfigureInjector(config);
//Permite el Cross Origin
app.UseCors(CorsOptions.AllowAll);
TokenConfig.ConfigureOAuth(app, config);
RouteConfig.Register(config);
WebApiConfig.Configure(config);
app.UseWebApi(config);
}
private static void BuildApp(IAppBuilder appBuilder, Action <HttpConfiguration> configure, bool useCors)
{
var config = new HttpConfiguration();
config.Formatters.Clear();
config.Formatters.Add(new JsonMediaTypeFormatter());
config.MapHttpAttributeRoutes();
if (configure != null)
{
configure(config);
}
if (useCors)
{
appBuilder.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
}
appBuilder.UseWebApi(config);
}
public void Configuration(IAppBuilder appBuilder)
{
var config = new HttpConfiguration();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
//**** Swagger ****
config.EnableSwagger(c => { c.SingleApiVersion("v1", "SampleClient"); }).EnableSwaggerUi();
var container = this.BuildContainer();
config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
appBuilder.UseAutofacMiddleware(container);
appBuilder.UseAutofacWebApi(config);
appBuilder.UseWebApi(config);
}
// This code configures Web API using Owin
private void WebConfiguration(IAppBuilder appBuilder)
{
// Configure Web API for self-host.
HttpConfiguration config = new HttpConfiguration();
// Format to JSON by default
config.Formatters.Clear();
config.Formatters.Add(new JsonMediaTypeFormatter());
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.EnsureInitialized();
appBuilder.UseWebApi(config);
}
private static void ConfigureWebApi(IAppBuilder inner)
{
var config = new HttpConfiguration();
ConfigureApiKeyAuthentication(config.Filters);
inner.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
SessionStore = new SessionStoreMediator()
});
config.DependencyResolver = GlobalConfiguration.Configuration.DependencyResolver;
config.MapHttpAttributeRoutes();
//config.Routes.MapHttpRoute(
// "DefaultApi",
// "{controller}/{id}",
// new {id = RouteParameter.Optional}
//);
inner.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
var myprovider = new MyAuthorizationServerProvider();
OAuthAuthorizationServerOptions options = new OAuthAuthorizationServerOptions()
{
AllowInsecureHttp = true,
TokenEndpointPath = new PathString("/api/token"),
AccessTokenExpireTimeSpan = TimeSpan.FromHours(3),
Provider = myprovider
};
app.UseOAuthAuthorizationServer(options);
app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());
HttpConfiguration config = new HttpConfiguration();
WebApiConfig.Register(config);
app.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
// token generation
app.UseOAuthAuthorizationServer(new OAuthAuthorizationServerOptions
{
// for demo purposes
AllowInsecureHttp = true,
TokenEndpointPath = new PathString("/token"),
AccessTokenExpireTimeSpan = TimeSpan.FromHours(1),
Provider = new AuthorizationServerProvider(),
AuthenticationType = OAuthDefaults.AuthenticationType
});
// token consumption
app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());
app.UseWebApi(WebApiConfig.Register());
app.MapSignalR(new HubConfiguration {
EnableDetailedErrors = true
});
}
public void Configuration(IAppBuilder app)
{
// Configure Web API for self-host.
HttpConfiguration config = new HttpConfiguration();
// Enable attribute based routing
// http://www.asp.net/web-api/overview/web-api-routing-and-actions/attribute-routing-in-web-api-2
config.MapHttpAttributeRoutes();
config.EnableCors();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
app.UseWebApi(config);
app.UseCors(CorsOptions.AllowAll);
app.MapSignalR();
}
public void Configuration(IAppBuilder app)
{
// 有关如何配置应用程序的详细信息，请访问 http://go.microsoft.com/fwlink/?LinkID=316888
//数据库初始化
System.Data.Entity.Database.SetInitializer(new Fhr.ModernHistory.Repositorys.Contexts.SampleData());
//实例化配置对象
HttpConfiguration = new HttpConfiguration();
//时间来不及 暂时不配置OAUTH
// ConfigureOAuth(app);
//注册所有区域
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(HttpConfiguration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
app.UseWebApi(HttpConfiguration);
//Swagger手动配置
SwaggerConfig.Register();
}
public void Configuration(IAppBuilder appBuilder)
{
// 创建 Web API 的配置
var config = new HttpConfiguration();
WebApiConfig.Register(config);
SwaggerConfig.Register(config);
config.Filters.Add(new JwtAuthFilterAttribute());
config.Filters.Add(new ModelValidationFilterAttribute());
config.Filters.Add(new CustomExceptionFilterAttribute());
//跨域配置
config.EnableCors(new EnableCorsAttribute("*", "*", "*"));
// 将路由配置附加到 appBuilder
appBuilder.UseWebApi(config);
}
public static void Register(HttpConfiguration config, IAppBuilder appBuilder)
{
// Web API routes
config.MapHttpAttributeRoutes();
// Web API configuration and services
config.Filters.Add(new AuditFilterAttribute());
config.Filters.Add(new ValidateModelAttribute());
config.Filters.Add(new CustomExceptionFilterAttribute());
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// send property names as camel case
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
appBuilder.UseWebApi(config);
}
public void Configuration(IAppBuilder appBuilder)
{
HttpConfiguration config = new HttpConfiguration();
//configure basic authentication
//a valid username/password combination is one in which they match
//hey, it's a demo, give me a break...
appBuilder.UseBasicAuthentication("DemoRealm", (u, p) => u.Equals(p));
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
appBuilder.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
//fix for cors
EnableCorsAttribute cors = new EnableCorsAttribute("*", "*", "*");
config.EnableCors(cors);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Formatters.Remove(config.Formatters.XmlFormatter);
//config.Formatters.JsonFormatter.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented;
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
app.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
EnsureAuthIndexes.Exist();
HttpConfiguration config = new HttpConfiguration();
DataProtectionProvider = app.GetDataProtectionProvider();
var container = SimpleInjectorInitializer.Initialize(config);
IClientService clientService;
using (container.BeginExecutionContextScope())
{
clientService = container.GetInstance <IClientService>();
}
WebApiConfig.Register(config);
app.UseOAuthAuthorizationServer(OAuthTokenOptions(clientService));
app.UseJwtBearerAuthentication(OAuthTokenConsumption());
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
app.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
config.Routes.MapHttpRoute(
name: "DefaultApi",
//routeTemplate: "api/{controller}/{id}",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
ConfigureCors(app);
AtivandoAcessTokens(app);
app.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.EnsureInitialized();
config.MessageHandlers.Add(new ServerCompressionHandler(new GZipCompressor(), new DeflateCompressor()));
app.Use((context, next) =>
{
var rqIndex = Interlocked.Increment(ref _index);
var duration = new Stopwatch();
duration.Start();
Trace.TraceInformation($"Skill Request({rqIndex}) {context.Request.Method} {context.Request.Path}");
//context.Environment.Add("name", object);
var result = next.Invoke();
duration.Stop();
Trace.TraceInformation($"Skill Response({rqIndex}) {context.Response.StatusCode} {context.Response.ReasonPhrase} {duration.ElapsedMilliseconds}ms");
return(result);
});
app.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
WebApiConfig.Register(config);
var builder = new ContainerBuilder();
// Register Web API controller in executing assembly.
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
// Register a product service to be used by the controller.
builder.Register(c => new ProductService()).As <IProductService>().InstancePerRequest();
var container = builder.Build();
config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
app.UseAutofacMiddleware(container);
app.UseAutofacWebApi(config);
app.UseWebApi(config);
}
// This code configures Web API. The Startup class is specified as a type
// parameter in the WebApp.Start method.
public void Configuration(IAppBuilder appBuilder)
{
// Configure Web API for self-host.
HttpConfiguration config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
config.EnsureInitialized();
appBuilder.UseWebApi(config);
Console.WriteLine("Available Apis:");
foreach (var api in config.Services.GetApiExplorer().ApiDescriptions)
{
Console.WriteLine("{0} {1}", api.HttpMethod, api.RelativePath);
}
}
public void Configuration(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
//--------------------------------------------------------------
// Web API configuration and services
var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
config.Formatters.JsonFormatter.SerializerSettings = new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
};
//--------------------------------------------------------------
// Routing staic
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}",
defaults: new { action = RouteParameter.Optional }
);
app.UseWebApi(config);
}
