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));
// Web API routes
config.MapHttpAttributeRoutes();
// enable CORS
config.EnableCors();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "PlayerApi",
routeTemplate: "api/{controller}/{action}/{name}",
defaults: new { teamName = RouteParameter.Optional }
);
}
public void ByPostShouldReturnCorrectResponse()
{
var controller = typeof(CategoriesController);
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
var httpServer = new HttpServer(config);
var httpInvoker = new HttpMessageInvoker(httpServer);
using (httpInvoker)
{
var request = new HttpRequestMessage
{
RequestUri = new Uri("http://test.com/api/categories/1"),
Method = HttpMethod.Get
};
var result = httpInvoker.SendAsync(request, CancellationToken.None).Result;
Assert.IsNotNull(result);
}
}
public static void Register(HttpConfiguration config)
{
config.EnableCors();
// Web API configuration and services
var clientID = WebConfigurationManager.AppSettings["auth0:ClientId"];
var clientSecret = WebConfigurationManager.AppSettings["auth0:ClientSecret"];
config.MessageHandlers.Add(new JsonWebTokenValidationHandler()
{
Audience = clientID,
SymmetricKey = clientSecret
});
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "WithActionApi",
routeTemplate: "api/{controller}/{action}/{fillupId}"
);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
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));
//Unity
var container = new UnityContainer();
container.RegisterType<IUnitOfWork, UnitOfWork>(new HierarchicalLifetimeManager());
container.RegisterType<IGenericRepository<Farmacia>, GenericRepository<Farmacia>>(new HierarchicalLifetimeManager());
config.DependencyResolver = new UnityResolver(container);
//Formatters
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
//GlobalConfiguration.Configuration.Formatters.XmlFormatter.SupportedMediaTypes.Clear();
//config.Formatters.Insert(0, new System.Net.Http.Formatting.JsonMediaTypeFormatter());
// Web API routes
config.MapHttpAttributeRoutes();
//config.EnableCors();
var cors = new EnableCorsAttribute("http://localhost:28285", "*", "*");
config.EnableCors(cors);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
}
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();
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
var cors = new EnableCorsAttribute("*", "*", "*");
config.EnableCors(cors);
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
//clear default formatters
config.Formatters.Clear();
config.Formatters.Add(new JsonMediaTypeFormatter());
//set formatters only json
var jsonFormatter = config.Formatters.OfType<JsonMediaTypeFormatter>().First();
//optional: set serializer settings here
config.Services.Replace(typeof(IContentNegotiator), new JsonContentNegotiator(jsonFormatter));
//jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
}
public static void Register(HttpConfiguration config)
{
//// Web API configuration and services
//// Web API routes
config.MapHttpAttributeRoutes();
//config.Routes.MapHttpRoute(
// name: "DefaultApi",
// routeTemplate: "api/{controller}/{id}",
// defaults: new { id = RouteParameter.Optional }
//);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
GlobalConfiguration.Configuration.Formatters.JsonFormatter.MediaTypeMappings.Add(new QueryStringMapping("type", "json", new MediaTypeHeaderValue("application/json")));
GlobalConfiguration.Configuration.Formatters.XmlFormatter.MediaTypeMappings.Add(new QueryStringMapping("type", "xml", new MediaTypeHeaderValue("application/xml")));
// Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
// To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
// For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
//config.EnableQuerySupport();
// To disable tracing in your application, please comment out or remove the following line of code
// For more information, refer to: http://www.asp.net/web-api
//config.EnableSystemDiagnosticsTracing();
}
public static void Register(HttpConfiguration config)
{
// Attribute routing.
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "ApiByAction",
routeTemplate: "api/{controller}/{action}",
defaults: new { action = "Get" }
);
config.Routes.MapHttpRoute(
name: "DefaultAPI",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "ApiById",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional },
constraints: new { id = @"^[0-9\-]+$" }
);
config.Routes.MapHttpRoute(
name: "ApiByName",
routeTemplate: "api/{controller}/{action}/{name}",
defaults: null,
constraints: new { name = @"^[a-z]+$" }
);
}
/// <summary>
/// Registra detalhes da configuração
/// </summary>
/// <param name="config"></param>
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
//var corsAttr = new EnableCorsAttribute("*", "*", "*");
//config.EnableCors(corsAttr);
// results should come out
// - with indentation for readability
// - in camelCase
var json = config.Formatters.JsonFormatter;
json.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented;
json.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
}
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));
// Enable cors
EnableCorsAttribute corsAttr = new EnableCorsAttribute("http://localhost:51227", "*", "*");
config.EnableCors(corsAttr);
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApiWithActions",
routeTemplate: "api/{controller}/{action}/{param1}/{param2}",
defaults: new
{
param1 = RouteParameter.Optional,
param2 = RouteParameter.Optional
}
);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{param1}/{param2}",
defaults: new
{
param1 = RouteParameter.Optional,
param2 = RouteParameter.Optional
}
);
}
public static void Register(HttpConfiguration config)
{
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApp",
routeTemplate: "app/{module}/approot",
defaults: new { controller = "App" }
);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Services.Add(typeof(IExceptionLogger), new WebExceptionLogger());
//JSON serialization
var json = config.Formatters.JsonFormatter;
json.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.Objects;
json.SerializerSettings.Converters.Add(new StringEnumConverter());
config.Formatters.Remove(config.Formatters.XmlFormatter);
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Enable cross origin requests to API
var cors = new EnableCorsAttribute(
origins: "*",
headers: "*",
methods: "*"
);
config.EnableCors(cors);
//var cors = new EnableCorsAttribute("*", "*", "*");
//config.EnableCors(cors);
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// Remove XML format in order to return JSON
var appXmlType =
config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault
(t => t.MediaType == "application/xml");
config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
}
public static void Register(HttpConfiguration config)
{
//----------- Web API configuration and services -----------
//如果不需要XML格式的数据,则去掉下面的注释
//config.Formatters.Remove(config.Formatters.XmlFormatter);
//JSON 格式化
config.Formatters.Remove(config.Formatters.JsonFormatter);
var jsonFormatter = new FieldsJsonMediaTypeFormatter();
#region SerializerSettings
var jsonResolve = new Share.IgnorableSerializerContractResolver();
jsonResolve.Ignore(typeof(Model.md_user), "loginpwd");
jsonResolve.Ignore(typeof(Model.dr_visit), "pkid");
jsonFormatter.SerializerSettings = new JsonSerializerSettings
{
ContractResolver = jsonResolve,
};
#endregion
config.Formatters.Add(jsonFormatter);
//----------- Web API routes -----------
config.MapHttpAttributeRoutes();
/* 注意
*
* 1)
* 只能定义（最多）一个符合以下条件的函数
* a）相同 GET/POST/PUT/DELETE动作的,
* b）只有一个名为id的参数
* 也就是,当定义类似SomeFunction(int id)的函数时,就需注意了。
*
* 2)
* 只能定义（最多一个）具有相同动作的无参函数,如Get()和GetSome() 会造成冲突
*
* 3)可空的参数也参与路由选择
* 例如 SomeFunction(int? p1)
* 如果 使用api/action/SomeFunction,不能进行路由
* 要使用api/action/SomeFunction?p1=10
* 或者 api/action/SomeFunction?p1
**/
config.Routes.MapHttpRoute(
name: "ActionMethod",
//如果使用 "api/{controller}/{action}",则DefaultApi就被覆盖
//所以使用了"api/{controller}/action/{action}"
//{fields}:指定返回所需对象的属性,多个属性用","（逗号）隔开
routeTemplate: "api/{controller}/action/{action}/{fields}",
defaults: new { action = RouteParameter.Optional, fields = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public void Configuration(IAppBuilder app)
{
var startupType = typeof(IStartup);
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
var startupTypes = assemblies.SelectMany(s => GetAssemblyTypes(s, startupType));
var startupInstances = new List <IStartup>();
foreach (var sType in startupTypes)
{
var startupInstance = Activator.CreateInstance(sType) as IStartup;
startupInstances.Add(startupInstance);
}
// Register HttpConfiguration
var config = new System.Web.Http.HttpConfiguration();
config.MapHttpAttributeRoutes();
foreach (var sType in startupInstances)
{
sType.Register(config, app);
}
// Set up all configuration.
foreach (var sType in startupInstances)
{
sType.Configuration(app);
}
app.UseWebApi(config);
}
public static void Register(HttpConfiguration config, IWindsorContainer container )
{
// Web API routes
config.MapHttpAttributeRoutes();
config.EnableCors();
GlobalConfiguration.Configuration.Services.Replace(typeof(IHttpControllerActivator),
new WindsorCompositionRoot(container));
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = UrlParameter.Optional }
);
RouteTable.Routes.MapRoute(
name: "Default",
url: "{controller}/{action}/{id}",
defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
);
var jsonFormatter = config.Formatters.OfType<JsonMediaTypeFormatter>().First();
jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new IsoDateTimeConverter());
var json = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
json.SupportedEncodings.Add(Encoding.GetEncoding(1252));
json.SerializerSettings.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat;
System.Web.Http.GlobalConfiguration.Configuration.Filters.Add(container.Resolve<IFilter>());
}
/// <summary>
/// Registers the custom/additional filters and message handlers.
/// </summary>
/// <param name="config">config parameter of HttpConfiguration</param>
public static void Register(HttpConfiguration config)
{
// Suppresing the Default Authentication of Host. e.g. IIS
config.SuppressDefaultHostAuthentication();
// Add OAuth Authentication Filter to enable OAuth 2.0
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
// Add AnetApiMessageHandler
config.MessageHandlers.Add(new AnetApiMessageHandler());
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional });
// Suppress Host Principal to enable custom Basic Authentication
config.SuppressHostPrincipal();
// Start: Added for camelcase
var formatters = GlobalConfiguration.Configuration.Formatters;
var jsonFormatter = formatters.JsonFormatter;
var settings = jsonFormatter.SerializerSettings;
// settings.Formatting = Formatting.Indented;
settings.ContractResolver = new CamelCasePropertyNamesContractResolver();
//// End: Added for camelcase
// Enforce HTTPS
config.Filters.Add(new AuthNet.Framework.Common.RequireHttpsAttribute());
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "ActionApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional });
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var jsonFormatter = config.Formatters.OfType<JsonMediaTypeFormatter>().First();
//config.Formatters.Remove(config.Formatters.XmlFormatter);
jsonFormatter.SerializerSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
//PreserveReferencesHandling = PreserveReferencesHandling.Objects,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
};
config.Formatters.Add(new MultipartFormFormatter());
}
public HttpConfiguration Configure(HttpConfiguration config)
{
config.MapHttpAttributeRoutes();
//let keep only the JSON formatter
config.Formatters.Clear();
config.Formatters.Add(new JsonMediaTypeFormatter());
// Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
// To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
// For more information, visit http://go.microsoft.com/fwlink/?LinkId=301869.
config.EnableQuerySupport(new QueryableAttribute() { MaxExpansionDepth = 5 });
// To disable tracing in your application, please comment out or remove the following line of code
// For more information, refer to: http://www.asp.net/web-api
config.EnableSystemDiagnosticsTracing();
//enable cross domain requests
config.EnableCors(new EnableCorsAttribute("*", "*", "*"));
//OData based rest endpoint
config.Routes.MapODataRoute(
"ODataRoute",
"rest",
new RestApiModelBuilder().GetEdmModel());
//RPC based rpc endpoint
config.Routes.MapHttpRoute(
name: "RPCRoute",
routeTemplate: "rpc/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
return config;
}
public static new void Install(HttpConfiguration config, IAppBuilder app)
{
config.SuppressHostPrincipal();
SecurityApi.Services.Contracts.IIdentityService identityService = UnityConfiguration.GetContainer().Resolve<SecurityApi.Services.Contracts.IIdentityService>();
app.UseOAuthAuthorizationServer(new OAuthOptions(identityService));
app.UseJwtBearerAuthentication(new SecurityApi.Auth.JwtOptions());
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
app.UseCors(CorsOptions.AllowAll);
app.MapSignalR();
var jSettings = new JsonSerializerSettings();
jSettings.Formatting = Formatting.Indented;
jSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.Remove(config.Formatters.XmlFormatter);
config.Formatters.JsonFormatter.SerializerSettings = jSettings;
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
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));
// The custom error handling and logging classes must be registered here
// Customized error handling and logging
config.Services.Replace(typeof(IExceptionHandler), new ServiceLayer.HandleError());
config.Services.Replace(typeof(IExceptionLogger), new ServiceLayer.LogError());
// The HTTP OPTIONS handler must be registered here
config.MessageHandlers.Add(new ServiceLayer.HandleHttpOptions());
// Web API routes
config.MapHttpAttributeRoutes();
// Added a default for "controller" so that we can use a root controller
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { controller = "Root", id = RouteParameter.Optional }
);
}
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 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();
// 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);
}
private void ConfigureWebApi(HttpConfiguration config)
{
config.MapHttpAttributeRoutes();
var jsonFormatter = config.Formatters.OfType<JsonMediaTypeFormatter>().First();
jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Configure default exception handling
config.Services.Replace(typeof(IExceptionHandler), new TextExceptionHandler());
config.Services.Add(typeof(IExceptionLogger), new Logger());
// Configure Web API to use only bearer token authentication.
config.SuppressDefaultHostAuthentication();
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
// Web API routes
config.MapHttpAttributeRoutes();
// The default controller when all else fails
config.Routes.MapHttpRoute(
name: "Default",
routeTemplate: "api/{controller}/{*id}",
defaults: new
{
controller = "Default",
action = "Get",
id = RouteParameter.Optional
});
// Enforce HTTPS
config.Filters.Add(new Filters.RequireHttpsAttribute());
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// Load basic support for sending WebHooks
config.InitializeCustomWebHooks();
// Load Azure Storage or SQL for persisting subscriptions
config.InitializeCustomWebHooksAzureStorage();
// config.InitializeCustomWebHooksSqlStorage();
// Load Azure Queued Sender for enqueueing outgoing WebHooks to an Azure Storage Queue
// config.InitializeCustomWebHooksAzureQueueSender();
// Load Web API controllers for managing subscriptions
config.InitializeCustomWebHooksApis();
}
public static new void Install(HttpConfiguration config, IAppBuilder app)
{
config.SuppressHostPrincipal();
app.UseCors(CorsOptions.AllowAll);
app.MapSignalR();
var jSettings = new JsonSerializerSettings();
jSettings.Formatting = Formatting.Indented;
jSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.Remove(config.Formatters.XmlFormatter);
config.Formatters.JsonFormatter.SerializerSettings = jSettings;
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
//2014/06/16 若以此設定在get/put的方法會造成404，因為參數api/products/1的products對到了area,1對到了controller,id=optional
// config.Routes.MapHttpRoute(
//name: "AreaAPI",
//routeTemplate: "api/{area}/{controller}/{id}",
//defaults: new { id = RouteParameter.Optional }
// //, constraints: new { area = @"\w{3}|\w{4}|\w{5}|\w{6}|\w{7}" }//限定Area才吃此設定，防put 404 error, 2014/06/16無效
//);
//test:http://localhost:3752/rd
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
return;
//2014/08/11重點為default的id約束及DefaultApiWithAction，可以使用明確的action來呼叫
//2014/08/11看起來WebApi最好的設定方式
//http://lonetechie.com/2013/03/04/fixing-multiple-actions-were-found-that-match-the-request-aspnet-webapi/
config.Routes.MapHttpRoute("DefaultApiWithId", "api/{controller}/{id}", new { id = RouteParameter.Optional }, new { id = @"\d+" });
config.Routes.MapHttpRoute("DefaultApiWithAction", "api/{controller}/{action}");
config.Routes.MapHttpRoute("DefaultApiGet", "api/{controller}", new { action = "Get" }, new { httpMethod = new HttpMethodConstraint(HttpMethod.Get) });
config.Routes.MapHttpRoute("DefaultApiPost", "api/{controller}", new { action = "Post" }, new { httpMethod = new HttpMethodConstraint(HttpMethod.Post) });
config.Routes.MapHttpRoute("DefaultApiPut", "api/{controller}", new { action = "Put" }, new { httpMethod = new HttpMethodConstraint(HttpMethod.Put) });
config.Routes.MapHttpRoute("DefaultApiDelete", "api/{controller}", new { action = "Delete" }, new { httpMethod = new HttpMethodConstraint(HttpMethod.Delete) });
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// OData
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Player>("Players");
builder.EntitySet<BattingDetail>("BattingDetails");
builder.EntitySet<BowlingDetail>("BowlingDetails");
builder.EntitySet<Country>("Countrys");
builder.EntitySet<Match>("Matches").EntityType.HasKey(m => m.MatchNumber);
config.AddODataQueryFilter();
config.MapODataServiceRoute(
routeName: "odata",
routePrefix: "odata",
model: builder.GetEdmModel());
}
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 static void Register(System.Web.Http.HttpConfiguration config)
{
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public WebViewer(ILogger logger, Action <Action <ISystemController, IRaceController> > queueCommand, IPlugin plugin, IKernel kernel)
{
//params to add:
//wifi hostspot?
//dhcp?
//dns?
//katana port
//static content path
_logger = logger;
this.Plugin = plugin;
//possibly do these as another plugin/dependency eg how bt or i2c works?
//optionally configure wifi as hotspot
//optionally configure dhcp
//optionally configure dns
//initialize owin/katana
_webApp = WebApp.Start("http://*:9000", app =>
{
var webApiConfig = new System.Web.Http.HttpConfiguration();
webApiConfig.MapHttpAttributeRoutes();
webApiConfig.Formatters.Clear();
webApiConfig.Formatters.Add(new JsonMediaTypeFormatter());
webApiConfig.Formatters.JsonFormatter.SerializerSettings =
new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
_resolver = new WebResolver(webApiConfig.DependencyResolver, logger, queueCommand, kernel);
webApiConfig.DependencyResolver = _resolver;
app.UseWebApi(webApiConfig);
var fs = new PhysicalFileSystem("/home/brook/Desktop/MrGibbs/src/MrGibbs.OnboardWebUI/Web");
app.UseFileServer(new FileServerOptions()
{
FileSystem = fs,
RequestPath = new PathString(""),
EnableDefaultFiles = true
});
});
//initialize static content
//initialize default page
//initialize webapi
//initialize websockets/signalr?
//create a ninject kernel specifically for the webapp
//add the logger and queue command, maybe state?
}
public static void Register(System.Web.Http.HttpConfiguration config)
{
config.EnableCors();
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute("DefaultApi1", "api/{controller}");
config.Routes.MapHttpRoute("DefaultApi2", "api/{controller}/{value}");
config.Routes.MapHttpRoute("DefaultApi3", "api/{controller}/{action}/{value}");
config.Routes.MapHttpRoute("DefaultApi4", "api/{controller}/{value1}/{value2}/{value3}", new { value1 = RouteParameter.Optional, value2 = RouteParameter.Optional, value3 = RouteParameter.Optional });
//Dim appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(Function(t) t.MediaType = "application/xml")
//config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType)
}
public static void RegisterApi(System.Web.Http.HttpConfiguration config)
{
config.MapHttpAttributeRoutes();
// Adds support for the webapi 1 style methods, e.g. /api/Users/
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.EnsureInitialized();
}
private HttpConfiguration ConfigureWebApi()
{
var config = new System.Web.Http.HttpConfiguration();
var enableCorsAttribute = new EnableCorsAttribute("*", "*", "*");
config.EnableCors(enableCorsAttribute);
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeWithQualityHeaderValue("text/html")
);
config.Formatters.Remove(config.Formatters.XmlFormatter);
config.Formatters.JsonFormatter.AddUriPathExtensionMapping("json", "application/json");
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
return(config);
}
public static void Register(System.Web.Http.HttpConfiguration config)
{
// Web-API-Konfiguration und -Dienste
// Web-API-Routen
config.MapHttpAttributeRoutes();
//ODataModelBuilder builder = new ODataConventionModelBuilder();
//builder.EntitySet<Contracts.IResident>("Residents");
//config.AddODataQueryFilter(new System.Web.Http.Filters.ActionFilterAttribute() );
//config.Routes.MapODataRoute("ODataRoute", "odata", GetEdmModel());
//ODataModelBuilder builder = new ODataConventionModelBuilder();
//builder.EntitySet<Models.ResidentViewModel>("Residents");
//config.MapODataServiceRoute(
// routeName: "ODataRoute",
// routePrefix: "odata",
// model: builder.GetEdmModel());
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Models.ResidentViewModel>("ResidentViewModels");
config.AddODataQueryFilter();
//config.MapODataServiceRoute(routeName: "oDataRoute", routePrefix: "odata", model: builder.GetEdmModel());
config.MapODataServiceRoute(routeName: "oDataRoute", routePrefix: "odata", model: builder.GetEdmModel());
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
//config.MapODataServiceRoute( "odata", null, GetEdmModel(), new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer));
config.EnsureInitialized();
}
public void Configuration(IAppBuilder app)
{
// For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=316888
// Enable the application to use bearer tokens to authenticate users
PublicClientId = "self";
OAuthAuthorizationServerOptions aAuthOptions = new OAuthAuthorizationServerOptions
{
TokenEndpointPath = new PathString("/Token"),
Provider = new ApplicationOAuthProvider(PublicClientId),
//AuthorizeEndpointPath = new PathString("/api/Account/ExternalLogin"),
AccessTokenExpireTimeSpan = TimeSpan.FromDays(14),
AllowInsecureHttp = true
};
app.UseOAuthBearerTokens(aAuthOptions);
var apiConfig = new System.Web.Http.HttpConfiguration();
apiConfig.SuppressDefaultHostAuthentication();
apiConfig.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
apiConfig.MapHttpAttributeRoutes();
apiConfig.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
app.UseWebApi(apiConfig);
//app.Run(context =>
//{
// //context.Response.ContentType = "plain/html";
// return context.Response.WriteAsync("Hello World!");
//});
}
/// <summary>
/// Maps the attribute-defined routes for the application.
/// </summary>
/// <param name="configuration">The server configuration.</param>
public static void MapHttpAttributeRoutes(this HttpConfiguration configuration)
{
configuration.MapHttpAttributeRoutes(new HttpRouteBuilder());
}
