public static void CustomizeConfig(HttpConfiguration config)
{
// Remove Xml formatters. This means when we visit an endpoint from a browser,
// Instead of returning Xml, it will return Json.
// More information from Dave Ward: http://jpapa.me/P4vdx6
config.Formatters.Remove(config.Formatters.XmlFormatter);
// Configure json camelCasing per the following post: http://jpapa.me/NqC2HH
// Here we configure it to write JSON property names with camel casing
// without changing our server-side data model:
var json = config.Formatters.JsonFormatter;
json.SerializerSettings.ContractResolver =
new CamelCasePropertyNamesContractResolver();
//json.SerializerSettings.Converters.Add(new IsoDateTimeConverter());
// Add model validation, globally
config.Filters.Add(new ValidationActionFilter());
config.Filters.Add(new ExceptionHandlingFilter());
//Add JSONP support
// uses WebApiContrib.Formatting.Jsonp that use net40
var formatter = new JsonpMediaTypeFormatter(json);
config.Formatters.Insert(0, formatter);
//config.EnableCors();
}
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 }
);
//below code is used for enabling cross domain ajax call
var jsonpFormatter = new JsonpMediaTypeFormatter(config.Formatters.JsonFormatter);
config.Formatters.Insert(0, jsonpFormatter);
//wiht class CustomJsonFormatter this is alternative solution for changing respond type in browser
//config.Formatters.Add(new CustomJsonFormatter());
//config.Formatters.Remove(config.Formatters.XmlFormatter);//will completely remove xml formatters
//config.Formatters.Remove(config.Formatters.JsonFormatter);
//config.Formatters.JsonFormatter.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented;//
//this is going to properly indent json data in respond
//now brower will support json respond
//config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new System.Net.Http.Headers.MediaTypeHeaderValue("text/html"));
//config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
var jsonpFormatter = new JsonpMediaTypeFormatter(config.Formatters.JsonFormatter);
config.Formatters.Add(jsonpFormatter);
var cors = new EnableCorsAttribute("http://localhost:51131/", "*", "GET,POST");
config.EnableCors(cors);
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "EmailApi",
routeTemplate: "api/{controller}/{email}",
defaults: new { email = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public static void Register(HttpConfiguration config)
{
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "Search-Series",
routeTemplate: "api/{controller}/{lang}/{inst}/{serie}/{query}",
defaults: new { inst = RouteParameter.Optional, lang = RouteParameter.Optional, serie = RouteParameter.Optional, query = RouteParameter.Optional }
);
var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
var jsonpFormatter = new JsonpMediaTypeFormatter(config.Formatters.JsonFormatter);
config.Formatters.Add(jsonpFormatter);
// 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 void IsJsonpRequest_ReturnsFalseForNonGetRequest(string httpMethod)
{
var request = new HttpRequestMessage(new HttpMethod(httpMethod), "http://example.org/");
string callback;
Assert.IsFalse(JsonpMediaTypeFormatter.IsJsonpRequest(request, "callback", out callback));
}
protected void Application_Start()
{
//Tells when migrations to run
var migrator = new DbMigrator(new Configuration());
migrator.Update();
//Only initialise when nnot already initialised.
if (!WebSecurity.Initialized)
{
WebSecurity.InitializeDatabaseConnection("DefaultConnection", "Users", "ID", "Username", true);
}
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
//Can enable CORS in web API 2.
GlobalConfiguration.Configuration.Formatters.Clear();
GlobalConfiguration.Configuration.Formatters.Add(new JsonMediaTypeFormatter());
//JsonP for cross origin (wraps JSON call in object)
var jsonPFormatter = new JsonpMediaTypeFormatter(GlobalConfiguration.Configuration.Formatters[0], "callback"); // jsonp callsback to callback
GlobalConfiguration.Configuration.Formatters.Insert(0, jsonPFormatter); //Insertred so this is hit first.
//Authentication "who" (User name and Password).
//Authorisation "rights" (What the authenticated person can do).
//Can use OAuth or Forms for this.
}
// This code configures Web API. The SippServer 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();
var cors = new EnableCorsAttribute("scratchx.org", "*", "*");
config.EnableCors(cors);
config.Routes.MapHttpRoute(
name: "Pedometer",
routeTemplate: "services/{controller}/data/{type}"
);
config.Routes.MapHttpRoute(
name: "Thing",
routeTemplate: "services/{controller}/status/{type}"
);
config.Routes.MapHttpRoute(
name: "Accelerometer",
routeTemplate: "services/{controller}"
);
config.Routes.MapHttpRoute(
name: "Gyro",
routeTemplate: "services/{controller}"
);
var jsonpFormatter = new JsonpMediaTypeFormatter(config.Formatters.JsonFormatter);
config.Formatters.Insert(0, jsonpFormatter);
appBuilder.UseWebApi(config);
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
config.EnableCors();
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}/{ext}",
defaults: new { id = RouteParameter.Optional, ext = "json" }
);
config.Formatters.JsonFormatter.AddUriPathExtensionMapping("json", "application/json");
config.Formatters.XmlFormatter.AddUriPathExtensionMapping("xml", "text/xml");
var jsonpFormatter = new JsonpMediaTypeFormatter(config.Formatters.JsonFormatter);
config.Formatters.Insert(0, jsonpFormatter);
jsonpFormatter.AddUriPathExtensionMapping("jsonp", "text/javascript");
//config.Formatters.JsonFormatter.MediaTypeMappings
// .Add(new RequestHeaderMapping("Accept",
// "text/html",
// StringComparison.InvariantCultureIgnoreCase,
// true,
// "application/json"));
}
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();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
//config.Formatters.Add(new CustomJsonFormatter());
//config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new System.Net.Http.Headers.MediaTypeHeaderValue("text/html"));
//config.Formatters.Remove(config.Formatters.XmlFormatter);
// config.Formatters.Remove(config.Formatters.JsonFormatter);
//config.Formatters.JsonFormatter.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented;
//config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
var JsonpFormatter = new JsonpMediaTypeFormatter(config.Formatters.JsonFormatter);
config.Formatters.Insert(0, JsonpFormatter);
//EnableCorsAttribute cors = new EnableCorsAttribute("*", "*", "*");
//config.EnableCors(cors);
}
public void GetJsonpCallback_ReturnsFalseForGetRequestWithNoCallback()
{
var request = new HttpRequestMessage(HttpMethod.Get, "http://example.org/");
var result = JsonpMediaTypeFormatter.GetJsonpCallback(request, "callback");
(result == null).Should().BeTrue();
}
public static void CustomizeConfig(HttpConfiguration config)
{
//REGISTER CompressedRequestHandler
config.MessageHandlers.Add(new CompressedRequestHandler());
// Remove Xml formatters. This means when we visit an endpoint from a browser,
// Instead of returning Xml, it will return Json.
// More information from Dave Ward: http://jpapa.me/P4vdx6
config.Formatters.Remove(config.Formatters.XmlFormatter);
// Configure json camelCasing per the following post: http://jpapa.me/NqC2HH
// Here we configure it to write JSON property names with camel casing
// without changing our server-side data model:
//var json = config.Formatters.JsonFormatter;
//json.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
//json.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
//remove standard JSON formatter
config.Formatters.Remove(config.Formatters.JsonFormatter);
//add JSONP formatter to support both JSON and JSONP
var jsonp = new JsonpMediaTypeFormatter();
jsonp.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
jsonp.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
config.Formatters.Add(jsonp);
// Add model validation, globally
config.Filters.Add(new ValidationActionFilter());
// config.Filters.Add(new AuthorizeAttribute());
//
//config.Filters.Add(new CustomSecurityAttribute());
//config.Filters.Add(new XchangeSecurityAttribute());
config.Filters.Add(new ExceptionHandlingAttribute());
}
public void IsJsonpRequest_ReturnsTrueForGetRequest()
{
var request = new HttpRequestMessage(HttpMethod.Get, "http://example.org/?callback=?");
string callback;
Assert.IsTrue(JsonpMediaTypeFormatter.IsJsonpRequest(request, "callback", out callback));
}
public static void Register(HttpConfiguration config)
{
//Add attribute route support
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "Example",
routeTemplate: "exampleApi/{id}",
defaults: new { controller = "Example", id = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// 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();
//Change json formatter to camel case instead of Pascal Default - Also change different aspects of the Formatter this way
var jsonFormatter = config.Formatters.OfType <JsonMediaTypeFormatter>().FirstOrDefault();
jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
jsonFormatter.SerializerSettings.Converters.Add(new LinkModelConverter());
CreateMediaTypes(jsonFormatter);
// Add support JSONP - Request need header Accept: application/javascript and request with ?cb=javascriptfunction
var formatter = new JsonpMediaTypeFormatter(jsonFormatter, "cb");
config.Formatters.Insert(0, formatter);
//Entire API
//Add nuget package microsoft ASP.NET Web API 2 Cross-Origin
//config.EnableCors(new EnableCorsAttribute("*", "*", "GET,POST"));
//If only on controllers or methods
//config.EnableCors();
//All cases for this filter force HTTPS
//config.Filters.Add(new RequireHttpsAttribute());
// Replace the Controller Configuration
//config.Services.Replace(typeof(IHttpControllerSelector), new ExampleVersionSelector(config));
// Configure Caching/ETag Support
//var connString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
// REMINDER: Make sure you've run the SQL Scripts in the Package Folder!
//var etagStore = new SqlServerEntityTagStore(connString);
//var cacheHandler = new CachingHandler(etagStore);
//config.MessageHandlers.Add(cacheHandler);
}
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();
//config.Routes.MapHttpRoute(
// name: "StudentV2Api",
// routeTemplate: "api/v2/students/{id}",
// defaults: new { id = RouteParameter.Optional, controller = "StudentsV2" }
//);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Services.Replace(typeof(IHttpControllerSelector), new CustomControllerSelector(config));
// Removing Json respose format so API can support only XML
//config.Formatters.Remove(config.Formatters.JsonFormatter);
// Web browser send accept header as "text/html" thats why XML is returned. Changing default format returned by browsers to JSON but leaving accept header as "text/html" what is missleading.
//config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
// Add custom JSON Formatter to handle dafault accept header "text/html" used by browsers
//config.Formatters.Add(new CustomJsonFormatter());
config.Formatters.Add(new CSVMediaTypeFormatter(new QueryStringMapping("format", "csv", "text/csv")));
// Setting camel case for Json response
config.Formatters.JsonFormatter.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented;
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
// Custom MediaType Accept Header versioning - enable xml and json
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/vnd.company_name.students.v1+json"));
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/vnd.company_name.students.v2+json"));
config.Formatters.XmlFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/vnd.company_name.students.v1+xml"));
config.Formatters.XmlFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/vnd.company_name.students.v2+xml"));
// Allow using ajax in a cross domain
JsonpMediaTypeFormatter jsonpFormatter = new JsonpMediaTypeFormatter(config.Formatters.JsonFormatter);
config.Formatters.Add(jsonpFormatter);
//// Enables and activates CORS settings globally, * - all
////EnableCorsAttribute enableCorsAttribute = new EnableCorsAttribute("*", "*", "GET, POST");
//EnableCorsAttribute enableCorsAttribute = new EnableCorsAttribute("*", "*", "*");
//config.EnableCors(enableCorsAttribute);
//// Enables and does not activate CORS settings in the application. Use [EnableCorsAttribute] attributes on WebApi Controllers to activate.
//config.EnableCors();
config.Filters.Add(new RequireHttpsAttribute());
}
protected override void UpdateConfiguration(WebRouteConfiguration configuration)
{
var f = JsonpMediaTypeFormatter.Create(configuration);
configuration.RemoveNonODataFormatters();
configuration.InsertFormatter(f);
configuration.Count().Filter().OrderBy().Expand().MaxTop(null);
}
public void IsJsonpRequest_ReturnsTrueForGetRequest()
{
var request = new HttpRequestMessage(HttpMethod.Get, "http://example.org/?callback=?");
var result = JsonpMediaTypeFormatter.GetJsonpCallback(request, "callback");
(result != null).Should().BeTrue();
(result.Value == "?").Should().BeTrue();
}
public static void Register(HttpConfiguration config)
{
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "Student",
routeTemplate: "enrollees/{id}/{action}",
defaults: new { Controller = "Student", action = RouteParameter.Optional },
constraints: new { id = "/d+" } // restricts id to be integer only -- not needed here but used as an example to bind regular expressions
// to proper parameter formats.
);
config.Routes.MapHttpRoute(
name: "OtherActions",
routeTemplate: "api/{controller}/{id}/{action}",
defaults: new { action = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "Classes",
routeTemplate: "classes/{action}",
defaults: new { Controller = "Student", action = RouteParameter.Optional }
);
/*
* The WebApiConfig class may require additional changes to add a route for this controller. Merge these statements into the Register method of the WebApiConfig class as applicable. Note that OData URLs are case sensitive.
*/
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Student>("Student");
config.Routes.MapODataServiceRoute("odata", "odata", builder.GetEdmModel());
// These two lines below change the json result formatting to use camel case instead of pascal case.
var jsonFormatter = config.Formatters.OfType <JsonMediaTypeFormatter>().FirstOrDefault();
//jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
jsonFormatter.SerializerSettings.ContractResolver = new DefaultContractResolver();
var formatter = new JsonpMediaTypeFormatter(jsonFormatter);
config.Formatters.Insert(0, formatter);
#if !DEBUG
//Force HTTPS on entire API
config.Filters.Add(new RequireHttpsAttribute());
#endif
// 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();
}
public static void Register(HttpConfiguration config)
{
config.Routes.MapHttpRoute(
name: "Food",
routeTemplate: "api/nutrition/foods/{foodid}",
defaults: new { controller = "foods", foodid = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "Measures",
routeTemplate: "api/nutrition/foods/{foodid}/measures/{id}",
defaults: new { controller = "measures", id = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "Diaries",
routeTemplate: "api/user/diaries/{diaryid}",
defaults: new { controller = "diaries", diaryid = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "DiaryEntries",
routeTemplate: "api/user/diaries/{diaryid}/entries/{id}",
defaults: new { controller = "diaryentries", id = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "DiarySummary",
routeTemplate: "api/user/diaries/{diaryid}/summary",
defaults: new { controller = "diarysummary" }
);
config.Routes.MapHttpRoute(
name: "Token",
routeTemplate: "api/token",
defaults: new { controller = "token" }
);
// 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();
var jsonFormatter = config.Formatters.OfType <JsonMediaTypeFormatter>().FirstOrDefault();
jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
// Add support JSONP
var formatter = new JsonpMediaTypeFormatter(jsonFormatter, "cb");
config.Formatters.Insert(0, formatter);
#if !DEBUG
// Force HTTPS on entire API
config.Filters.Add(new RequireHttpsAttribute());
#endif
}
public static void RegisterFormatters(MediaTypeFormatterCollection formatters)
{
// Insert the JSONP formatter in front of the standard JSON formatter.
var jsonpFormatter = new JsonpMediaTypeFormatter(formatters.JsonFormatter);
formatters.Insert(0, jsonpFormatter);
var jsonFormatter = formatters.JsonFormatter;
jsonFormatter.SerializerSettings = new JsonSerializerSettings {
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
}
public static void Register(HttpConfiguration config)
{
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var jsonpFormatter = new JsonpMediaTypeFormatter(config.Formatters.JsonFormatter);
config.Formatters.Insert(0, jsonpFormatter);
}
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));
#region Formatter
// Json Formatter - CamelCase
config.Formatters.JsonFormatter.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented;
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver =
new CamelCasePropertyNamesContractResolver();
// If we need to customize more formats activate one of the options below:
//Return only JSON from ASP.NET Web API Service:
//config.Formatters.Remove(config.Formatters.XmlFormatter);
//Return only XML from ASP.NET Web API Service:
//config.Formatters.Remove(config.Formatters.JsonFormatter);
//Return JSON instead of XML from ASP.NET Web API Service when a request is made from the browser:
//First Sollution
//config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
//Second Sollution
//config.Formatters.Add(new CustomJsonFormatter());
#endregion
#region DiffDomain
//JSONP-To allow cross domain ajax calls by enabling JSONP
//Install-Package WebApiContrib.Formatting.Jsonp
var jsonpFormatter = new JsonpMediaTypeFormatter(config.Formatters.JsonFormatter);
config.Formatters.Insert(0, jsonpFormatter);
//To allow cross domain ajax calls by enabling CORS
//Install-Package Microsoft.AspNet.WebApi.Cors
//Origins,Headers,Methods
//EnableCorsAttribute cors = new
// EnableCorsAttribute("http://localhost:8023,http://blabla:8041", "*", "GET,POST");
EnableCorsAttribute cors = new EnableCorsAttribute("*", "*", "*");
config.EnableCors(cors);
#endregion
#region routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
#endregion
}
// WebApiConfig.Register() method includes a parameter of HttpConfiguration type which is then used to configure the Web API
// Web api configuration http://www.tutorialsteacher.com/webapi/configure-web-api WebApiConfig.Register()
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 }
);
// Følgende sørger for at den rå json data som brugeren får når de benytter Get metoden er ordentligt indented.
// Og har camelcase isdedet for pascalcase
config.Formatters.JsonFormatter.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented;
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.Add(new CustomJsonFormatter());
// http://www.tutorialsteacher.com/webapi/web-api-formatters Media type formatters
// Web api configuration http://www.tutorialsteacher.com/webapi/configure-web-api
// Jsonp (json with padding):
// Web browser tilladder ikke at ren json kan blive consumed med mindre man benytter noget som jsonp
// AJAX (XMLHttpRequest) doesn’t allow cross domain communication due to security reasons. https://www.codeproject.com/Tips/631685/JSONP-in-ASP-NET-Web-API-Quick-Get-Started
// Web browsers tillader at javascript kode kan blive 'consumed' så derfor 'wrapper' vi alt vores json data ind i en javascript funktion ved hjælp fra jsonp
/* JsonpMediaTypeFormatter is a JSONP MediaTypeFormatter implementation for ASP.NET Web API.
* i added it to my Web API solution, by running Install-Package WebApiContrib.Formatting.Jsonp from your NuGet Package Manager console in Visual Studio. */
// Her ærklærer vi variablen jsonpFormatter og sætter den lig med en ny instance af JsonpMediaTypeFormatter
// Får at få fat i jsonformatter skal vi pass'er config objekt ind i constructoren som, som bliver specificeret i Register funktionens parameter længere oppe
var jsonpFormatter = new JsonpMediaTypeFormatter(config.Formatters.JsonFormatter); // Husk det er new jsonP der bliver lavet
// Nu vil vi gerne have jsonp Formatet ind ind vores collection af formater i config objektet (config.Formatters)
// Ved index position 0 vil vi indsætte jsonp formatet
config.Formatters.Insert(0, jsonpFormatter);
// Https configuration
// Følgende gør at man kan benytte https protokollen i hele Web api applikationen (For alle controllere og action methods).
config.Filters.Add(new RequireHttpsAttribute());
// Gør at man i hele Web api applikationen skal være logget ind
config.Filters.Add(new BasicAuthenticationAttribute());
}
public void Initialize(HttpControllerSettings settings,
HttpControllerDescriptor descriptor)
{
var jsonFormatter = settings.Formatters.JsonFormatter;
jsonFormatter.SerializerSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
// Insert the JSONP formatter in front of the standard JSON formatter.
var jsonpFormatter = new JsonpMediaTypeFormatter(settings.Formatters.JsonFormatter);
settings.Formatters.Insert(0, jsonpFormatter);
}
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();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var jsonpFormatter = new JsonpMediaTypeFormatter(config.Formatters.JsonFormatter);
config.Formatters.Insert(0, jsonpFormatter);
}
// 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.EnableCors();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var jsonpFormatter = new JsonpMediaTypeFormatter(config.Formatters.JsonFormatter);
config.Formatters.Insert(0, jsonpFormatter); // inject the new formatter into the collection of formatters as the first formatter
appBuilder.UseWebApi(config);
}
public static void Register(HttpConfiguration config)
{
config.SuppressHostPrincipal();
WebApiUnityActionFilterProvider.RegisterFilterProviders(config);
config.EnableCors(new EnableCorsAttribute("*", "*", "*"));
// Web API configuration and services
var jsonp = new JsonpMediaTypeFormatter();
jsonp.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
config.Formatters.Insert(0, jsonp);
GlobalConfiguration.Configuration.Formatters
.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
config.Formatters.Remove(config.Formatters.XmlFormatter);
}
public static void Register(HttpConfiguration config)
{
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "cep/{zipCode}",
defaults: new { controller = "Address", action = "Get" },
constraints: new { zipCode = @"^\d+$" }
);
var jsonpFormatter = new JsonpMediaTypeFormatter {
Indent = true
};
config.Formatters.Insert(0, jsonpFormatter);
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.JsonFormatter.Indent = true;
config.EnableSystemDiagnosticsTracing();
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
config.EnableCors(new EnableCorsAttribute("*", headers: "*", methods: "*"));
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var jsonpFormatter = new JsonpMediaTypeFormatter(config.Formatters.JsonFormatter);
config.Formatters.Add(jsonpFormatter);
}
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: "Student",
routeTemplate: "api/school/Student/{id}",
defaults: new { controller = "Student", id = RouteParameter.Optional }
);
var jsonFormatter = config.Formatters.OfType <JsonMediaTypeFormatter>().FirstOrDefault();
jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
jsonFormatter.SerializerSettings.Converters.Add(new LinkModelConverter());
CreateMediaTypes(jsonFormatter);
// support jsonp
var formatter = new JsonpMediaTypeFormatter(jsonFormatter, "cb");
config.Formatters.Insert(0, formatter);
// Replace the Controller Configuration
config.Services.Replace(typeof(IHttpControllerSelector),
new SchoolControllerSelector(config));
// Configure Caching support etag
var cacheHandler = new CachingHandler(config);
config.MessageHandlers.Add(cacheHandler);
// Add support CORS
// var attr = new EnableCorsAttribute("*", "*", "GET");
// config.EnableCors(attr);
}
public static void Register(HttpConfiguration config)
{
// Configuración y servicios de API web
// Rutas de API web
var jsonpFormatter = new JsonpMediaTypeFormatter(config.Formatters.JsonFormatter);
config.Formatters.Add(jsonpFormatter);
EnableCorsAttribute cors = new EnableCorsAttribute("*", "*", "GET,POST");
config.EnableCors(cors);
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
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 }
);
var jsonFormatter = new JsonpMediaTypeFormatter(config.Formatters.JsonFormatter);
config.Formatters.Insert(0, jsonFormatter);
config.Formatters.Add(new CustomJsonFromatter());
//config.Formatters.Remove(config.Formatters.XmlFormatter);
//config.Formatters.JsonFormatter.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented;
}
