public static void Register(IAppBuilder app)
{
HttpConfiguration httpConfig = new HttpConfiguration();
httpConfig.Formatters.Clear();
PartialJsonMediaTypeFormatter partialJsonMediaTypeFormatter = new PartialJsonMediaTypeFormatter()
{
IgnoreCase = true
};
partialJsonMediaTypeFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
//partialJsonMediaTypeFormatter.MediaTypeMappings.Add(new QueryStringMapping("type", "json", new MediaTypeHeaderValue("application/json")));
httpConfig.Formatters.Add(partialJsonMediaTypeFormatter);
XmlMediaTypeFormatter xmlMediaTypeFormatter = new XmlMediaTypeFormatter();
//xmlMediaTypeFormatter.MediaTypeMappings.Add(new QueryStringMapping("type", "xml", new MediaTypeHeaderValue("application/xml")));
httpConfig.Formatters.Add(xmlMediaTypeFormatter);
httpConfig.MessageHandlers.Add(new XHttpMethodOverrideHandler());
httpConfig.Services.Add(typeof(IExceptionLogger), new UnhandledExceptionLogger());
httpConfig.MapHttpAttributeRoutes();
httpConfig.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
httpConfig.EnableCors();
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
//app.UseWebApi(httpConfig);
app.UseNinjectMiddleware(() => NinjectConfig.CreateKernel.Value);
app.UseNinjectWebApi(httpConfig);
}
private void ConfigureWebApi(IAppBuilder app)
{
var config = new HttpConfiguration();
WebApiConfig.Register(config);
app.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder app)
{
app.UseNinjectMiddleware(() => _kernel.Value);
HttpConfiguration webApiConfig = new HttpConfiguration();
WebApiConfig.Register(webApiConfig);
app.UseWebApi(webApiConfig);
//Ninject
app.UseNinjectWebApi(webApiConfig);
//AutoMapper
if (!AutoMapperConfig.IsInitialized)
{
AutoMapperConfig.Initialize();
}
//Database path
string codeBase = System.Reflection.Assembly.GetExecutingAssembly().CodeBase;
System.UriBuilder uri = new System.UriBuilder(codeBase);
string path = System.Uri.UnescapeDataString(uri.Path);
var parent = System.IO.Directory.GetParent(path);
while (parent.Name.IndexOf("TAL.Developer.Test.") == -1)
{
parent = System.IO.Directory.GetParent(parent.FullName);
}
parent = System.IO.Directory.GetParent(parent.FullName); // ROOT
System.AppDomain.CurrentDomain.SetData("DataDirectory", parent.FullName);
}
// 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 }
);
var jsonFormatter = config.Formatters.OfType <JsonMediaTypeFormatter>().First();
jsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
// jsonFormatter.SerializerSettings.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
appBuilder.UseErrorPage();
appBuilder.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
appBuilder.UseNinjectMiddleware(CreateKernel);
appBuilder.UseNinjectWebApi(config);
//appBuilder.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var bootstrapper = new SlowPokeWarsBootstrapper();
bootstrapper.Initialize();
var webApiConfiguration = new HttpConfiguration();
webApiConfiguration.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}");
// Server Setup
app.MapSignalR(new HubConfiguration
{
EnableJavaScriptProxies = false, // true if you do not want to write proxies yourself
EnableJSONP = true, // here b/c server starts on port that differes from UI server port.
EnableDetailedErrors = true,
// required, if you want your DI container to resolve hub dependencies.
Resolver = bootstrapper.GetSignalRDependencyResolver()
});
app.UseNinjectMiddleware(bootstrapper.GetKernel);
app.UseNinjectWebApi(webApiConfiguration);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
//ConfigureOAuth(app);
//ConfigureOAuthTokenGeneration(app);
WebApiConfig.Register(config);
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
app.UseNinjectMiddleware(() => NinjectConfig.CreateKernel.Value);
app.UseNinjectWebApi(config);
// Branch the pipeline here for requests that start with "/signalr"
app.Map("/signalr", map =>
{
// Setup the CORS middleware to run before SignalR.
// By default this will allow all origins. You can
// configure the set of origins and/or http verbs by
// providing a cors options with a different policy.
map.UseCors(CorsOptions.AllowAll);
var hubConfiguration = new HubConfiguration
{
// You can enable JSONP by uncommenting line below.
// JSONP requests are insecure but some older browsers (and some
// versions of IE) require JSONP to work cross domain
// EnableJSONP = true
};
// Run the SignalR pipeline. We're not using MapSignalR
// since this branch already runs under the "/signalr"
// path.
hubConfiguration.EnableDetailedErrors = true;
map.RunSignalR(hubConfiguration);
});
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
config.EnableCors();
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "BreezeApi",
routeTemplate: "breeze/{controller}/{action}"
);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var json = config.Formatters.JsonFormatter;
json.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.Objects;
config.Formatters.Remove(config.Formatters.XmlFormatter);
json.SerializerSettings.ContractResolver = new Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver();
json.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented;
app.UseNinjectMiddleware(CreateKernel);
app.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var policy = new CorsPolicy
{
AllowAnyHeader = true,
AllowAnyMethod = true,
SupportsCredentials = true
};
policy.ExposedHeaders.Add("Authorization");
app.UseCors(new CorsOptions
{
PolicyProvider = new CorsPolicyProvider
{
PolicyResolver = context => Task.FromResult(policy)
}
});
var config = new HttpConfiguration();
WebApiConfig.Register(config);
app.UseNinjectMiddleware(CreateKernel);
app.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var config = CreateHttpConfiguration();
app.UseNinjectMiddleware(Ninject.CreateKernel);
app.UseNinjectWebApi(config);
}
public void ConfigureWebApi(IAppBuilder app)
{
var config = new HttpConfiguration();
// attribute routing
config.MapHttpAttributeRoutes();
// Convention-based routing.
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// only use json for webapi output
var jsonFormatter = new JsonMediaTypeFormatter();
config.Services.Replace(typeof(IContentNegotiator), new JsonContentNegotiator(jsonFormatter));
// enable elmah
config.Services.Add(typeof(IExceptionLogger), new ElmahExceptionLogger());
// internally calls app.UseWebApi
app.UseNinjectWebApi(config);
}
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 builder)
{
builder.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
LoginPath = new PathString("/Account/Login"),
LogoutPath = new PathString("/Account/Logout"),
ExpireTimeSpan = TimeSpan.FromMinutes(5.0)
});
PublicClientId = "self";
OuAuthAuthorizationServerOptions = new OAuthAuthorizationServerOptions
{
TokenEndpointPath = new PathString("/Token"),
Provider = new AppOauthProvider(PublicClientId),
AuthorizeEndpointPath = new PathString("/Account/ExternalLogin"),
AccessTokenExpireTimeSpan = TimeSpan.FromHours(4.0),
AllowInsecureHttp = true
};
builder.UseOAuthBearerTokens(OuAuthAuthorizationServerOptions);
HttpConfiguration configuration = new HttpConfiguration();
WebApiConfig.Register(configuration);
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
builder.UseNinjectMiddleware(() => NinjectConfig.CreateKernel.Value);
builder.UseNinjectWebApi(configuration);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
OAuthConfig.ConfigureOAuth(app);
HandlersConfig.RegisterGlobalHandlers(config);
RoutesConfig.Register(config);
FormattersConfig.Configure(config);
FiltersConfig.RegisterGlobalFilters(config);
BindersConfig.RegisterGlobalBinders(config);
TracingConfig.Configure();
TokenConfig.ConfigureOAuthTokenConsumption(app);
AutoMapperConfig.ConfigMappers();
app.UseCors(CorsOptions.AllowAll);
app.UseNinjectMiddleware(IoC.CreateKernel);
app.UseNinjectWebApi(config);
}
public static void Register(IAppBuilder app)
{
var config = app.GetConfiguration();
app.UseNinjectMiddleware(CreateKernel);
app.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder appBuilder)
{
var config = new HttpConfiguration();
WebApiConfig.Register(config);
appBuilder.UseNinjectMiddleware(CreateKernel);
appBuilder.UseNinjectWebApi(config);
}
/// <summary>
/// Configures the OWIN runtime
/// </summary>
/// <param name="app">The application builder</param>
public void Configuration(IAppBuilder app)
{
app.UseOAuthAuthorizationServer(BlobstoreConfiguration.CreateAuthorizationOptions());
app.UseOAuthBearerAuthentication(BlobstoreConfiguration.CreateAuthenticationOptions());
app.UseNinjectMiddleware(BlobstoreConfiguration.CreateKernel);
app.UseNinjectWebApi(BlobstoreConfiguration.CreateHttpConfiguration(AddElmahHandleErrorApiAttribute));
}
public void Configuration(IAppBuilder app)
{
// For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=316888
app.UseCors(CorsOptions.AllowAll);
app.MapSignalR();
app.UseNinjectMiddleware(CreateKernel);
app.UseNinjectWebApi(WebApiConfiguration());
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
WebApiConfig.Register(config);
app.UseNinjectMiddleware(() => NinjectConfig.CreateKernel.Value);
app.UseNinjectWebApi(config);
}
public static void CoreConfiguration(IAppBuilder app, Func <IKernel> containerFactory)
{
var config = WebApiConfiguration.CreateConfiguration();
app.UseNinjectMiddleware(containerFactory);
app.UseNinjectWebApi(config);
config.EnsureInitialized();
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
WebApiConfig.Register(config);
app.UseNinjectMiddleware(() => NinjectConfig.CreateKernel.Value);
app.UseOAuthBearerTokens(oAuthCondig);
app.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute("DefaultApi", "myservice/{controller}/{id}", new { id = RouteParameter.Optional });
app.UseNinjectMiddleware(CreateKernel);
app.UseNinjectWebApi(config);
}
private void RegisterWebApi(IAppBuilder app)
{
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
app.UseNinjectWebApi(config);
}
public IKernel ConfigureNinject(IAppBuilder app, HttpServer server)
{
var kernel = CreateKernel();
app.UseNinjectMiddleware(() => kernel);
app.UseNinjectWebApi(server);
return(kernel);
}
public void Configuration(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
ConfigureAuth(app);
WebApiConfig.Register(config);
app.UseNinjectMiddleware(CreateKernel);
app.UseNinjectWebApi(config);
}
public static void ConfigureWebApi(this IAppBuilder app)
{
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.Formatters.Remove(config.Formatters.XmlFormatter);
app.UseNinjectWebApi(config);
}
/// <summary>
/// Configures the OWIN runtime
/// </summary>
/// <param name="app">The application builder</param>
public void Configuration(IAppBuilder app)
{
app.UseOAuthAuthorizationServer(BlobstoreConfiguration.CreateAuthorizationOptions());
app.UseOAuthBearerAuthentication(BlobstoreConfiguration.CreateAuthenticationOptions());
app.UseNinjectMiddleware(BlobstoreConfiguration.CreateKernel);
app.UseNinjectWebApi(BlobstoreConfiguration.CreateHttpConfiguration());
app.UseWelcomePage();
}
public void Configuration(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
ConfigureOAuth(app);
WebApiConfig.Register(config);
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
app.UseNinjectMiddleware(CreateKernel);
app.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
ConfigureAuth(app);
app.UseNinjectMiddleware(() => NinjectConfig.CreateKernel.Value);
app.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
WebApiConfig.Register(config);
//Ninject Configuration
app.UseCors(CorsOptions.AllowAll);
app.UseNinjectMiddleware(IoC.Configure);
app.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
WebApiConfig.Register(config);
MappingConfig.RegisterMappings();
app.UseNinjectMiddleware(() => NinjectConfig.CreateKernel.Value);
app.UseNinjectWebApi(config);
}
public void Configure(IAppBuilder appBuilder, IKernel kernel)
{
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.MapDefinedRoutes();
appBuilder.UseNinjectMiddleware(() => kernel);
appBuilder.UseNinjectWebApi(config);
}
public IKernel ConfigureNinject(IAppBuilder app, HttpConfiguration httpConfig)
{
var kernel = CreateKernel(app);
RegisterServiceLocator(kernel);
app.UseNinjectMiddleware(() => kernel);
app.UseNinjectWebApi(httpConfig);
return kernel;
}
// 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();
appBuilder.UseNinjectMiddleware(CreateKernel);
appBuilder.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder app)
{
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
var config = new HttpConfiguration();
WebApiConfig.Register(config);
app.UseNinjectMiddleware(() => NinjectConfig.CreateKernel.Value);
app.UseOAuthBearerTokens(oAuthCondig);
app.UseNinjectWebApi(config);
}
private void ConfigureNinject(IAppBuilder app)
{
var config = GlobalConfiguration.Configuration;
app.UseNinjectMiddleware(() => _kernel.Value);
app.UseNinjectWebApi(config);
System.Web.Http.Dependencies.IDependencyResolver ninjectResolver = new NinjectResolver(_kernel.Value);
config.DependencyResolver = ninjectResolver;
}
public IKernel ConfigureNinject(IAppBuilder app)
{
var config = new HttpConfiguration();
var kernel = CreateKernel();
app.UseNinjectMiddleware(() => kernel);
app.UseNinjectWebApi(config);
return(kernel);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
ConfigureOAuth(app);
app.UseNinjectMiddleware(() => _kernel.Value);
WebApiConfig.Register(config);
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
app.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder app)
{
ConfigureOAuth(app);
HttpConfiguration config = new HttpConfiguration();
WebApiConfig.Register(config);
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
//app.UseWebApi(config);
app.UseNinjectMiddleware(CreateKernel);
app.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder app)
{
ConfigureAuth(app);
var config = new HttpConfiguration();
WebApiConfig.Register(config);
app.UseNinjectMiddleware(() => NinjectConfig.CreateKernel.Value);
app.UseNinjectWebApi(config);
config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
}
/// <summary>
/// The configuration.
/// </summary>
/// <param name="app">
/// The app.
/// </param>
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
var kernel = CreateKernel();
app.UseNinjectMiddleware(() => kernel);
OAuthConfig.Configure(app, kernel);
WebApiConfig.Register(config);
app.UseNinjectWebApi(config);
}
public IKernel ConfigureNinject(IAppBuilder app, HttpConfiguration httpConfig)
{
var kernel = CreateKernel(app);
RegisterServiceLocator(kernel);
app.UseNinjectMiddleware(() => kernel);
app.UseNinjectWebApi(httpConfig);
return(kernel);
}
/// <summary>
/// Creates a configuration.
/// </summary>
/// <param name="app">
/// The app.
/// </param>
public void Configuration(IAppBuilder app)
{
var webApiConfiguration = new HttpConfiguration();
webApiConfiguration.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "{controller}/{id}",
defaults: new { id = RouteParameter.Optional, controller = "values" });
app.UseNinjectMiddleware(CreateKernel);
app.UseNinjectWebApi(webApiConfiguration);
}
public void ConfigureWebApi(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
var jsonFormatter = config.Formatters.OfType<JsonMediaTypeFormatter>().First();
jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
jsonFormatter.SerializerSettings.DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc;
app.UseNinjectWebApi(config);
}
public void Configure(IAppBuilder appBuilder, IKernel kernel)
{
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.MapDefinedRoutes();
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
log4net.Config.XmlConfigurator.Configure();
appBuilder.UseNinjectMiddleware(() => kernel);
appBuilder.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
config.Formatters.Clear();
config.Formatters.Add(new JsonMediaTypeFormatter());
config.MapHttpAttributeRoutes();
config.EnsureInitialized();
app.UseNinjectMiddleware(CreateKernel);
app.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder app)
{
app.UseCors(CorsOptions.AllowAll);
ConfigureAuth(app);
var config = new HttpConfiguration();
WebApiConfig.Register(config);
DatabaseConfig.Initialize();
MappingConfig.Initialize();
app.UseNinjectMiddleware(() => NinjectConfig.CreateKernel.Value);
app.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
ConfigureOAuth(app);
WebApiConfig.Register(config);
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
app.UseWebApi(config);
ModelMapper.MapAllModels();
app.UseNinjectMiddleware(() => NinjectConfig.CreateKernel.Value);
app.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder appBuilder)
{
var config = new HttpConfiguration();
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new System.Net.Http.Headers.MediaTypeHeaderValue("text/html"));
var jsonFormatter = config.Formatters.JsonFormatter;
jsonFormatter.SerializerSettings.Converters.Add(new StringEnumConverter());
WebApiConfig.Register(config);
appBuilder.UseWebApi(config);
appBuilder.UseNinjectMiddleware(() => CreateKernel(config));
appBuilder.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder app)
{
AutoMapperConfig.RegisterMappings(Assembly.GetExecutingAssembly());
app.UseNinjectMiddleware(NinjectConfig.CreateKernel);
ConfigureAuth(app);
var config = new HttpConfiguration();
WebApiConfig.Register(config);
app.UseNinjectWebApi(config);
}
/// <summary>
/// Creates a collection of API configurations from a list of pledge configurations.
/// </summary>
/// <param name="app">The application object to initialise.</param>
/// <returns></returns>
public void Configuration(IAppBuilder app)
{
var httpConfig = new HttpConfiguration();
ConfigureOAuth(app);
WebApiConfig.Register(httpConfig);
app.UseCors(CorsOptions.AllowAll);
app.MapSignalR();
app.UseNinjectMiddleware(() => NinjectWebCommon.CreateKernel.Value);
app.UseNinjectWebApi(httpConfig);
httpConfig.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
IOHelper.ConfigureStreamDirectories();
}
/// <summary>
/// Configures the app with a custom Ninject kernel.
/// </summary>
/// <param name="app">An <see cref="IAppBuilder" /> reference.</param>
/// <param name="kernel">The custom Ninject <see cref="IKernel" />.</param>
internal static void ConfigureWebApi( IAppBuilder app, IKernel kernel )
{
var config = new HttpConfiguration
{
IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always
};
config.MapODataServiceRoute( "TestOdataRoute",
null,
ModelBuilder.GetEdmModel() );
config.EnsureInitialized();
app.UseNinjectMiddleware( () => kernel );
app.UseNinjectWebApi( config );
}
public void Configuration(IAppBuilder appBuilder)
{
#if DEBUG
appBuilder.UseErrorPage();
#endif
var config = new HttpConfiguration();
// Enable Windows Auth
var listener = (HttpListener)appBuilder.Properties[typeof(HttpListener).FullName];
listener.AuthenticationSchemes = AuthenticationSchemes.IntegratedWindowsAuthentication;
// Enable CORS support
appBuilder.UseCors(CorsOptions.AllowAll);
// Disable XML support
config.Formatters.Remove(config.Formatters.XmlFormatter);
// Pretty JSON
config.Formatters.JsonFormatter.SerializerSettings.DateFormatHandling = DateFormatHandling.IsoDateFormat;
config.Formatters.JsonFormatter.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new StringEnumConverter());
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
#if DEBUG
config.Formatters.JsonFormatter.SerializerSettings.Formatting = Formatting.Indented;
#endif
// Default Router
config.MapHttpAttributeRoutes();
// Load Static Files
appBuilder.UseFileServer(new FileServerOptions()
{
RequestPath = PathString.Empty,
FileSystem = new PhysicalFileSystem(@".\Web")
});
// Enable Message Handlers
config.MessageHandlers.Add(new ApiLoggingHandler()); // TODO: For any non-200 OK response, this throws a 500 error
// ArgumentException: The 'DelegatingHandler' list is invalid because the property 'InnerHandler' of 'ApiLoggingHandler' is not null. Parameter name: handlers
// Endable Ninject
appBuilder.UseNinjectMiddleware(DependencyConfig.CreateKernel);
appBuilder.UseNinjectWebApi(config);
appBuilder.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
HttpConfiguration httpConfig = new HttpConfiguration();
WebApiConfig.Register(httpConfig);
ConfigureOAuthTokenGeneration(app);
ConfigureOAuthTokenConsumption(app);
//ConfigureWebApi(httpConfig);
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
app.UseNinjectMiddleware(() => NinjectConfig.CreateKernel.Value);
app.UseNinjectWebApi(httpConfig);
app.UseWebApi(httpConfig);
}
public void Configuration(IAppBuilder app)
{
ConfigureOAuth(app);
var config = new HttpConfiguration();
WebApiConfig.Register(config);
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
#region Ninject with OWIN
//app.UseWebApi(config); // Replace by => UseNinjectWebApi(config)
app.UseNinjectMiddleware(() => NinjectConfig.CreateKernel.Value);
app.UseNinjectWebApi(config);
#endregion
}
public virtual void Startup(IAppBuilder appBuilder)
{
// Configure Web API for self-host.
using (HttpConfiguration config = new HttpConfiguration())
{
// Web API routes
config.MapHttpAttributeRoutes();
// Configure Formatters
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
config.EnsureInitialized();
appBuilder.UseNinjectMiddleware(() => MainKernel.Instance.Kernel);
appBuilder.UseNinjectWebApi(config);
}
}
public void Configuration(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
ConfigureOAuth(app);
// Any connection or hub wire up and configuration should go here
app.MapSignalR();
GlobalHost.HubPipeline.RequireAuthentication();
GlobalHost.HubPipeline.AddModule(new ApplicationHubPipelineModule());
WebApiConfig.Register(config);
AutomapperConfig.Initialize();
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
app.UseNinjectMiddleware(() => Domain.Helpers.NinjectResolver.CreateKernel.Value);
app.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
//config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.XmlFormatter.UseXmlSerializer = true;
log4net.Config.XmlConfigurator.Configure();
//config.Services.Add(typeof(IExceptionLogger), new GeneralExceptionLogger());
//config.Services.Replace(typeof(IExceptionHandler), new GeneralExceptionHandler());
//config.Services.Replace(typeof(ITraceWriter), new TraceWriter());
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{accountnumbers}",
defaults: null
);
app.UseNinjectMiddleware(CreateKernel);
app.UseNinjectWebApi(config);
}
public void Configuration(IAppBuilder app)
{
app.UseNinjectMiddleware(ApiConfiguration.CreateKernel);
app.UseNinjectWebApi(ApiConfiguration.CreateHttpConfiguration());
}
