| public static Register ( HttpConfiguration config ) : void | ||
| config | HttpConfiguration | |
| return | void | |
public static bool ShouldMapTo <TController>(this string fullDummyUrl,
string action, HttpMethod httpMethod, Dictionary <string, object> parameters = null)
{
var request = new HttpRequestMessage(httpMethod, fullDummyUrl);
var config = new HttpConfiguration();
WebApiConfig.Register(config);
config.EnsureInitialized();
var route = RouteRequest(config, request);
var controllerName = typeof(TController).Name;
if (route.Controller.Name != controllerName)
{
throw new Exception(String.Format(
"The specified route '{0}' does not match the expected controller '{1}'", fullDummyUrl, controllerName));
}
if (route.Action.ToLowerInvariant() != action.ToLowerInvariant())
{
throw new Exception(String.Format(
"The specified route '{0}' does not match the expected action '{1}'", fullDummyUrl, action));
}
if (parameters != null && parameters.Any())
{
foreach (var param in parameters)
{
if (route.RouteData.Values.All(kvp => kvp.Key != param.Key))
{
throw new Exception(String.Format(
"The specified route '{0}' does not contain the expected parameter '{1}'", fullDummyUrl, param));
}
var paramValue = String.Empty;
if (param.Value != null)
{
paramValue = param.Value.ToString();
}
if (!route.RouteData.Values[param.Key].Equals(paramValue))
{
throw new Exception(String.Format(
"The specified route '{0}' with parameter '{1}' and value '{2}' does not equal does not match supplied value of '{3}'",
fullDummyUrl, param.Key, route.RouteData.Values[param.Key], param.Value));
}
}
}
return(true);
}
protected void Application_Start()
{
Trace.Listeners.Add(new NLogTraceListener());
//ExceptionlessClient.Default.Log = new NLogExceptionlessLog();
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
ExceptionlessClient.Default.Configuration.UseTraceLogger();
ExceptionlessClient.Default.Configuration.UseReferenceIds();
ExceptionlessClient.Default.RegisterWebApi(GlobalConfiguration.Configuration);
}
// 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: "Default",
routeTemplate: "{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
WebApiConfig.Register(config);
appBuilder.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
var config = WebApiConfig.Register();
var options = new OAuthAuthorizationServerOptions
{
AllowInsecureHttp = true,
TokenEndpointPath = new PathString("/token"),
AccessTokenExpireTimeSpan = TimeSpan.FromHours(8),
Provider = new AuthorizationServerProvider((ApplicationUserManager)config.DependencyResolver.GetService(typeof(ApplicationUserManager)))
};
app.UseOAuthAuthorizationServer(options);
app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());
app.UseWebApi(config);
}
protected void Application_Start()
{
DisplayModeProvider.Instance.Modes.Insert(0, new DefaultDisplayMode("iPhone")
{
ContextCondition = (context => context.GetOverriddenUserAgent().IndexOf
("iPhone", StringComparison.OrdinalIgnoreCase) >= 0)
});
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
BundleMobileConfig.RegisterBundles(BundleTable.Bundles);
}
public void Setup()
{
Server = TestServer.Create(app =>
{
var config = new HttpConfiguration();
WebApiConfig.Register(config);
config.DependencyResolver = new NinjectDependencyResolver(NinjectTestInjector.CreateKernel(GetInjections()));
app.UseWebApi(config);
});
//Bit of a hack to make sure that the repository is seeded
//before each test, but at the same time that it does not
//seed each time it is loaded which forgets state if it is
//queried multiple times during a single test
ReSeed();
}
protected void Application_Start()
{
Bootstrapper.Initialise();
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
// Configurando o AutoMapper para registrar os profiles
// de mapeamento durante a inicialização da aplicação.
AutoMapperRegister.RegisterMappings();
}
public void Configuration(IAppBuilder app)
{
// For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=316888
app.UseIdentityServerBearerTokenAuthentication(new IdentityServerBearerTokenAuthenticationOptions
{
Authority = "http://10.10.27.36:4044", //Your Identity Server address
});
var config = new HttpConfiguration();
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.JsonFormatter.UseDataContractJsonSerializer = false;
WebApiConfig.Register(config);
app.UseWebApi(config);
}
private void SetupControllerForPost(ApiController controller)
{
// Setup the controller's Request.
var httpConfiguration = new HttpConfiguration();
WebApiConfig.Register(httpConfiguration);
var httpRouteData = new HttpRouteData(
httpConfiguration.Routes["DefaultApi"],
new HttpRouteValueDictionary {
{ "controller", "tags" }
});
controller.Request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/tags/");
controller.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, httpConfiguration);
controller.Request.Properties.Add(HttpPropertyKeys.HttpRouteDataKey, httpRouteData);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
AuthConfig.RegisterAuth();
StructuremapMvc.Start();
CustomGlobalConfig.Customize(GlobalConfiguration.Configuration);
Database.SetInitializer(new DropCreateDatabaseIfModelChanges <MainContext>());
}
public void Initialize()
{
WebApiConfig.Register(System.Web.Http.GlobalConfiguration.Configuration);
//db > entityframe migrations init
//Database.SetInitializer<DBEntities>(new MigrateDatabaseToLatestVersion<DBEntities, W3S_GCS.Migrations.Configuration>());
//using (DBEntities db = new DBEntities()) {
// db.Database.Initialize(true);
//}
//db > via package actions
PackageActions.InitDatabase();
LanguageInstaller.CheckAndInstallLanguageActions();
}
protected void Application_Start()
{
try
{
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
AuthConfig.RegisterAuth();
GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
}
catch
{
}
}
protected void Application_Start()
{
WebApiConfig.Register(GlobalConfiguration.Configuration);
GlobalConfiguration.Configuration.Formatters.Remove(
GlobalConfiguration.Configuration.Formatters.XmlFormatter);
var container = new Container();
this.Register(GlobalConfiguration.Configuration, container);
this.AddFilters(GlobalConfiguration.Configuration);
GlobalConfiguration.Configuration.DependencyResolver =
new SimpleInjectorWebApiDependencyResolver(container);
}
public static HttpResponseMessage GetSiteRoot()
{
HttpResponseMessage response = null;
var httpConfiguration = new HttpConfiguration();
WebApiConfig.Register(httpConfiguration);
using (var server = new HttpServer(httpConfiguration))
{
var request = new HttpRequestMessage(HttpMethod.Get, new Uri("http://localhost/api"));
using (var client = new HttpClient(server))
{
response = client.SendAsync(request).Result;
}
}
return(response);
}
//coloquei static e comentei http
public static void Configuration(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
// Configure Dependency Injection
var container = new UnityContainer();
DependencyResolver.Resolve(container);
config.DependencyResolver = new UnityResolver(container);
WebApiConfig.Register(config);
ConfigureOAuth(app, container.Resolve <IUserService>());
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
app.UseWebApi(config);
}
protected void Application_Start()
{
MvcHandler.DisableMvcResponseHeader = true;
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
//self
IocRegisterRun.Current.Register();
DependencyResolver.SetResolver(ServiceLocator.Current.Resolve <IDependencyResolver>());
ModelBinders.Binders.Add(typeof(PagerRequest), ServiceLocator.Current.Resolve <PagerRequestBinder>());
}
public void TestInit()
{
// Start OWIN testing HTTP server with Web API support
this.httpTestServer = TestServer.Create(appBuilder =>
{
var config = new HttpConfiguration();
WebApiConfig.Register(config);
var startup = new Startup();
startup.ConfigureAuth(appBuilder);
appBuilder.UseWebApi(config);
});
this.httpClient = this.httpTestServer.HttpClient;
}
public override bool Matches(object item)
{
var request = (HttpRequestMessage)item;
if (request != null)
{
var httpConfiguration = new HttpConfiguration(new HttpRouteCollection());
WebApiConfig.Register(httpConfiguration);
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = httpConfiguration.Routes.GetRouteData(request);
var controllerBuilder = new TestControllerBuilder(request, httpConfiguration);
return(controller == controllerBuilder.GetControllerName());
}
return(false);
}
public void Configuration(IAppBuilder app)
{
HttpConfiguration = new HttpConfiguration();
// force token authentication
HttpConfiguration.SuppressDefaultHostAuthentication();
HttpConfiguration.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
ConfigureOAuth(app);
UnityConfig.RegisterComponents(HttpConfiguration);
app.UseCors(CorsOptions.AllowAll);
RouteConfig.RegisterRoutes(RouteTable.Routes);
var hubConfiguration = new HubConfiguration {
EnableDetailedErrors = true, EnableJavaScriptProxies = true
};
app.MapSignalR("/signalr", hubConfiguration);
//HttpConfiguration.Services.Replace(typeof (IHttpControllerSelector),
// new VersionControllerSelector(HttpConfiguration));
HttpConfiguration.Filters.Add(new AsyncLoggingFilter());
HttpConfiguration.MessageHandlers.Add(new HttpLoggingHandler());
SwaggerConfig.Register(HttpConfiguration);
//trace provider
//var traceWriter = new SystemDiagnosticsTraceWriter()
//{
// IsVerbose = true
//};
//HttpConfiguration.Services.Replace(typeof(ITraceWriter), traceWriter);
//HttpConfiguration.EnableSystemDiagnosticsTracing();
//ThrottleConfig.Register(HttpConfiguration);
WebApiConfig.Register(HttpConfiguration);
app.UseWebApi(HttpConfiguration);
app.UseStageMarker(PipelineStage.MapHandler);
}
protected override void AppStart()
{
WireUpDependencyResolvers();
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
GlobalConfiguration.Configuration.Formatters.Add(new QrMediaFormatter());
GlobalConfiguration.Configuration.MessageHandlers.Add(
new AuthenticationHandler(Container.Resolve <IAccessTokenRepository>(),
Container.Resolve <IUserRepository>()));
GlobalConfiguration.Configuration.MessageHandlers.Add(new ResponseHeaderHandler());
}
public void Configuration(IAppBuilder appBuilder)
{
var config = Startup.HttpConfiguration;
var json = config.Formatters.JsonFormatter.SerializerSettings;
//json.ContractResolver = new CamelCasePropertyNamesContractResolver();
json.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
//HttpConfiguration httpConfiguration = new HttpConfiguration();
WebApiConfig.Register(config);
appBuilder.UseWebApi(config);
ConfigureSwashbuckle(config);
AutoMapperConfig.Initialize();
}
static void Main(string[] args)
{
//var configuration = new HttpSelfHostConfiguration("http://localhost:8086");
var configuration = new MySelfHostConfiguration("https://localhost:8086");
WebApiConfig.Register(configuration);
DtoMapperConfig.CreateMaps();
IocConfig.RegisterDependencyResolver(configuration);
using (HttpSelfHostServer server = new HttpSelfHostServer(configuration))
{
server.OpenAsync().Wait();
Console.WriteLine("Press Enter to terminate the server...");
Console.ReadLine();
}
}
public void Configuration(IAppBuilder appBuilder)
{
HttpConfiguration config = new HttpConfiguration();
appBuilder.UseOAuthAuthorizationServer(new OAuthAuthorizationServerOptions()
{
AllowInsecureHttp = true,
TokenEndpointPath = new PathString("/token"),
AccessTokenExpireTimeSpan = TimeSpan.FromDays(1),
Provider = new SimpleAuthorizationServerProvider()
});
appBuilder.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());
WebApiConfig.Register(config);
appBuilder.UseCors(CorsOptions.AllowAll);
appBuilder.UseWebApi(config);
}
public void SetUp()
{
var configuration = new HttpConfiguration();
WebApiConfig.Register(configuration);
var queryProcessor = configuration.DependencyResolver.GetService(typeof(IQueryProcessor)) as IQueryProcessor;
Subject = new QueryController(queryProcessor, null)
{
Request = new HttpRequestMessage
{
RequestUri = new Uri("http://localhost/api/query/BarQuery?Id=1")
},
Configuration = configuration
};
}
public void Configuration(IAppBuilder app)
{
var container = SetupUnity();
ConfigureOAuth(app, container);
HttpConfiguration config = new HttpConfiguration();
config.DependencyResolver = new UnityDependencyResolver(container);
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
WebApiConfig.Register(config);
app.UseWebApi(config);
config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
config.Formatters.JsonFormatter.SerializerSettings.DateFormatString = "dd.MM.yyyy.";
}
public void InsertData_RoutingPath_Returns_Ok()
{
var config = new HttpConfiguration();
WebApiConfig.Register(config);
var request = new HttpRequestMessage(new HttpMethod("GET"), @"http://localhost:58786/api/data");
config.EnsureInitialized();
var routeDataCollection = config.Routes.GetRouteData(request);
var routeData = routeDataCollection.Values["MS_SubRoutes"] as IHttpRouteData[];
var route = routeData[0].Route;
//Assert
Assert.IsNotNull(routeDataCollection);
Assert.AreEqual("api/data", route.RouteTemplate);
}
public void Configuration(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
var container = ConfigureDependencies();
config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
app.UseAutofacLifetimeScopeInjector(container);
ConfigureAuth(app);
app.UseAutofacMiddleware(container);
WebApiConfig.Register(config);
app.UseCors(CorsOptions.AllowAll);
app.UseWebApi(config);
}
public static void Initialize(TestContext testContext)
{
NinjectConfig.DependenciesRegistration = kernel =>
{
kernel.Bind(typeof(IRepository <User>)).ToConstant(Repositories.GetUsersRepository());
kernel.Bind(typeof(IRepository <RealEstate>)).ToConstant(Repositories.GetRealEstatesRepository());
kernel.Bind(typeof(IRepository <Comment>)).ToConstant(Repositories.GetCommentsRepository());
};
AutoMapperConfig.RegisterMappings(Assemblies.WebApi);
var config = new HttpConfiguration();
WebApiConfig.Register(config);
MyWebApi.IsUsing(config);
}
protected void Application_Start()
{
ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(new RazorViewEngine());
ModelBinders.Binders.DefaultBinder = new SharpModelBinder();
ModelValidatorProviders.Providers.Add(new ClientDataTypeModelValidatorProvider());
this.InitializeServiceLocator();
BundleConfig.RegisterBundles(BundleTable.Bundles);
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(GlobalConfiguration.Configuration);
RouteRegistrar.RegisterRoutesTo(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
}
public static RouteHelper Create()
{
if (_instance == null)
{
_instance = new RouteHelper();
_instance.Config = new HttpConfiguration();
WebApiConfig.Register(_instance.Config);
var server = new HttpServer(_instance.Config);
_instance._client = new HttpClient(server);
_instance._client.BaseAddress = new System.Uri("http://localhost:57394/odata");
//_instance._client.DefaultRequestHeaders
// .Accept
// .Add(new MediaTypeWithQualityHeaderValue("application/json"));//ACCEPT header
}
//_instance._client.DefaultRequestHeaders.Clear();
return(_instance);
}