public static void Register(HttpConfiguration config)
{
var cors = new EnableCorsAttribute("*", "*", "GET, POST, PUT, DELETE, OPTIONS", "Signature");
config.EnableCors();
// Web API 配置和服务
config.Formatters.Clear();
var jsonFormatter = new JsonMediaTypeFormatter();
// Convert all dates to UTC type
jsonFormatter.SerializerSettings.DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc;
// Convert all dates to Microsoft type（"\/Date(ticks)\/ "）
//jsonFormatter.SerializerSettings.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.MicrosoftDateFormat;
jsonFormatter.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented;
jsonFormatter.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.All;
jsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.Add(jsonFormatter);
//config.Services.Replace(typeof(IContentNegotiator), new JsonContentNegotiator(jsonFormatter));
// Web API 路由
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
// GET api/values/5
public HttpResponseMessage Get(int? id)
{
if (id == null)
throw new HttpResponseException(HttpStatusCode.NotFound);
var result = new User
{
Age = 34,
Birthdate = DateTime.Now,
ConvertedUsingAttribute = DateTime.Now,
Firstname = "Ugo",
Lastname = "Lattanzi",
IgnoreProperty = "This text should not appear in the reponse",
Salary = 1000,
Username = "******",
Website = new Uri("http://www.tostring.it")
};
var formatter = new JsonMediaTypeFormatter();
var json = formatter.SerializerSettings;
json.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat;
json.DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc;
json.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
json.Formatting = Newtonsoft.Json.Formatting.Indented;
json.ContractResolver = new CamelCasePropertyNamesContractResolver();
json.Culture = new CultureInfo("en-US");
return Request.CreateResponse(HttpStatusCode.OK, result, formatter);
}
public static void UseJsonOnly(this HttpConfiguration config)
{
var jsonFormatter = new JsonMediaTypeFormatter();
config.Services.Replace(typeof(IContentNegotiator), new JsonOnlyContentNegotiator(jsonFormatter));
config.Formatters.Clear();
config.Formatters.Add(jsonFormatter);
}
public static void ConfigureWebApi(HttpConfiguration httpConfiguration, EntityApp app,
LogLevel logLevel = LogLevel.Basic,
WebHandlerOptions webHandlerOptions = WebHandlerOptions.DefaultDebug) {
// Logging message handler
var webHandlerStt = new WebCallContextHandlerSettings(logLevel, webHandlerOptions);
var webContextHandler = new WebCallContextHandler(app, webHandlerStt);
httpConfiguration.MessageHandlers.Add(webContextHandler);
// Exception handling filter - to handle/save exceptions
httpConfiguration.Filters.Add(new ExceptionHandlingFilter());
// Formatters - add formatters with spies, to catch/log deserialization failures
httpConfiguration.Formatters.Clear();
httpConfiguration.Formatters.Add(new StreamMediaTypeFormatter("image/jpeg", "image/webp")); //webp is for Chrome
var xmlFmter = new XmlMediaTypeFormatter();
httpConfiguration.Formatters.Add(xmlFmter);
var jsonFmter = new JsonMediaTypeFormatter();
// add converter that will serialize all enums as strings, not integers
jsonFmter.SerializerSettings.Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter());
var resolver = jsonFmter.SerializerSettings.ContractResolver = new JsonContractResolver(jsonFmter);
httpConfiguration.Formatters.Add(jsonFmter);
//Api configuration
if (app.ApiConfiguration.ControllerInfos.Count > 0)
ConfigureSlimApi(httpConfiguration, app);
}
public void Configuration(IAppBuilder app)
{
var config = new HttpConfiguration();
var container = ConfigureAutoFac.ConfigureMvc();
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
//Dit op Configure laten staan, dit wordt namelijk niet in web requests gebruikt
// Remove the old formatter, add the new one.
var formatter = new JsonMediaTypeFormatter();
formatter.SerializerSettings = new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = new CamelCasePropertyNamesContractResolver(),
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
};
config.Formatters.Remove(config.Formatters.JsonFormatter);
config.Formatters.Add(formatter);
config.Formatters.Remove(config.Formatters.XmlFormatter);
WebApiConfig.Register(config);
app.UseCors(CorsOptions.AllowAll);
app.UseAutofacMiddleware(container);
app.UseAutofacMvc();
app.UseAutofacWebApi(config);
app.UseWebApi(config);
ConfigureAuth(app);
}
public void TestMethod1()
{
try
{
Task serviceTask = new Task();
serviceTask.TaskId = 1;
serviceTask.Subject = "Test Task";
serviceTask.StartDate = DateTime.Now;
serviceTask.DueDate = null;
serviceTask.CompletedDate = DateTime.Now;
serviceTask.Status = new Status
{
StatusId = 3,
Name = "Completed",
Ordinal = 2
};
serviceTask.Links = new System.Collections.Generic.List<Link>();
serviceTask.Assignees = new System.Collections.Generic.List<User>();
serviceTask.SetShouldSerializeAssignees(true);
var formatter = new JsonMediaTypeFormatter();
var content = new ObjectContent<Task>(serviceTask, formatter);
var reuslt = content.ReadAsStringAsync().Result;
}
catch(Exception ex)
{
Assert.Fail(ex.Message);
}
}
/// <summary>
/// Helper method to create ErrorRespone
/// </summary>
/// <param name="request">This should be the source request. For Eg: </param>
/// <param name="body"></param>
/// <returns></returns>
public static HttpResponseMessage CreateErrorResponse(HttpRequestMessage request, ErrorResponseBody body)
{
var jsonFormatter = new JsonMediaTypeFormatter();
jsonFormatter.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
return request.CreateResponse<ErrorResponseBody>(body.Status, body, jsonFormatter);
}
public static void Register(HttpConfiguration config)
{
try
{
// Find assembly from path defined in web.config
var path = PayAtTable.API.Properties.Settings.Default.DataRepositoryAssembly;
var mappedPath = System.Web.Hosting.HostingEnvironment.MapPath(path);
Assembly assembly = Assembly.LoadFrom(mappedPath);
// Register data repository implementations with the IoC container
var container = TinyIoCContainer.Current;
container.Register(typeof(IOrdersRepository), LoadInstanceFromAssembly(typeof(IOrdersRepository), assembly)).AsPerRequestSingleton();
container.Register(typeof(ITablesRepository), LoadInstanceFromAssembly(typeof(ITablesRepository), assembly)).AsPerRequestSingleton();
container.Register(typeof(IEFTPOSRepository), LoadInstanceFromAssembly(typeof(IEFTPOSRepository), assembly)).AsPerRequestSingleton();
container.Register(typeof(ITendersRepository), LoadInstanceFromAssembly(typeof(ITendersRepository), assembly)).AsPerRequestSingleton();
container.Register(typeof(ISettingsRepository), LoadInstanceFromAssembly(typeof(ISettingsRepository), assembly)).AsPerRequestSingleton();
// Uncomment the following code to load a local data repository in this project rather than an external DLL
//container.Register<IOrdersRepository, DemoRepository>().AsPerRequestSingleton();
//container.Register<ITablesRepository, DemoRepository>().AsPerRequestSingleton();
//container.Register<IEFTPOSRepository, DemoRepository>().AsPerRequestSingleton();
//container.Register<ITendersRepository, DemoRepository>().AsPerRequestSingleton();
//container.Register<ISettingsRepository, DemoRepository>().AsPerRequestSingleton();
// Set Web API dependancy resolver
System.Web.Http.GlobalConfiguration.Configuration.DependencyResolver = new TinyIocWebApiDependencyResolver(container);
// Uncomment the following code to support XML
//var xmlMediaTypeFormatter = new XmlMediaTypeFormatter();
//xmlMediaTypeFormatter.AddQueryStringMapping("format", "xml", "text/xml");
//config.Formatters.Add(xmlMediaTypeFormatter);
// Add JSON formatter
var jsonMediaTypeFormatter = new JsonMediaTypeFormatter() { SerializerSettings = new Newtonsoft.Json.JsonSerializerSettings() { NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore } };
jsonMediaTypeFormatter.AddQueryStringMapping("format", "json", "application/json");
config.Formatters.Add(jsonMediaTypeFormatter);
var json = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
json.SerializerSettings.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
// Web API2 routes
config.MapHttpAttributeRoutes();
// Uncomment the following code to support WEB API v1 routing
//config.Routes.MapHttpRoute(
// name: "DefaultApi",
// routeTemplate: "api/{controller}/{id}",
// defaults: new { id = RouteParameter.Optional }
//);
// Uncomment the following to add a key validator to the message pipeline.
// This will check that the "apikey" parameter in each request matches an api key in our list.
config.MessageHandlers.Add(new ApiKeyHandler("key"));
}
catch (Exception ex)
{
log.ErrorEx((tr) => { tr.Message = "Exception encounted during configuration"; tr.Exception = ex; });
throw ex;
}
}
public HttpResponseMessage Get()
{
try
{
var formatter = new JsonMediaTypeFormatter();
var json = formatter.SerializerSettings;
json.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.MicrosoftDateFormat;
json.DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc;
json.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
json.Formatting = Newtonsoft.Json.Formatting.Indented;
json.ContractResolver = new CamelCasePropertyNamesContractResolver();
var lang = _bhtaEntities.Languages.ToList()
.Select(m => new LanguageModel()
{
Id = m.Id,
CategoryId = m.CategoryId,
Description = m.Description,
Category = new CategoryModel() { Id = m.Category.Id, Name = m.Category.Name, Description = m.Category.Description, Permalink = m.Category.Permalink },
Image = string.IsNullOrEmpty(m.Image) ? null : ValueConfig.LinkImage + m.Image,
KeyLanguage = m.KeyLanguage,
Sound = string.IsNullOrEmpty(m.Sound) ? null : ValueConfig.LinkSound + m.Sound,
ValueLanguage = _js.Deserialize<LanguageName>(m.ValueLanguage)
});
return Request.CreateResponse(HttpStatusCode.OK, lang, formatter);
}
catch (Exception exception)
{
return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exception.ToString());
}
}
public static void Register(HttpConfiguration config)
{
config.Formatters.Clear();
//config.Formatters.Add(new XmlMediaTypeFormatter());
var formater = new JsonMediaTypeFormatter();
//formater.SerializerSettings.Converters.Add(new DateTimeConverterHelper());
formater.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Serialize;
config.Formatters.Add(formater);
// 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 for all origins, all headers, and all methods,
var cors = new EnableCorsAttribute("*", "*", "*");
config.EnableCors(cors);
config.MessageHandlers.Add(new ApiLoggerHandler());
}
public Task<List<IdentityProviderInformation>> GetAsync(string protocol)
{
var url = string.Format(
"https://{0}.{1}/v2/metadata/IdentityProviders.js?protocol={2}&realm={3}&context={4}&version=1.0",
AcsNamespace,
"accesscontrol.windows.net",
protocol,
Realm,
Context);
var jsonFormatter = new JsonMediaTypeFormatter();
jsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/javascript"));
var formatters = new List<MediaTypeFormatter>()
{
jsonFormatter
};
var client = new HttpClient();
var t1 = client.GetAsync(new Uri(url));
var t2 = t1.ContinueWith(
innerTask =>
{
return t1.Result.Content.ReadAsAsync<List<IdentityProviderInformation>>(formatters);
});
var t3 = t2.ContinueWith<List<IdentityProviderInformation>>(
innerTask =>
{
return t2.Result.Result;
});
return t3;
}
public static void Register(HttpConfiguration config)
{
// HAL content negotiation.
var jsonFormatter = new JsonMediaTypeFormatter
{
// JSON settings: Do not show empty fields and camelCase field names.
SerializerSettings =
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new CamelCasePropertyNamesContractResolver()
}
};
config.Services.Replace(typeof(IContentNegotiator), new HalContentNegotiator(jsonFormatter));
// Catch and log all unhandled exceptions.
config.Services.Add(typeof(IExceptionLogger), new MyExceptionLogger());
// Do not include error details (e.g. stacktrace) in responses.
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Never;
// Web API routes
config.MapHttpAttributeRoutes();
// Default routes werkt niet, dus ik ga alle routes wel met de hand in RouteConfig.cs zetten...
//config.Routes.MapHttpRoute(name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional });
GlobalConfiguration.Configuration.Filters.Add(new BasicAuthenticationFilter(active: true));
}
private static void ConfigureDefaults(HttpConfiguration config)
{
//config.Filters.Add(new ExceptionActionFilter());
//config.Filters.Add(new ValidationActionFilter());
//Delete all formatter and add only JSON formatting for request and response
config.Formatters.Clear();
var formatter = new JsonMediaTypeFormatter()
{
SerializerSettings =
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
DateFormatHandling = DateFormatHandling.MicrosoftDateFormat,
DateTimeZoneHandling = DateTimeZoneHandling.Utc
},
};
config.Formatters.Add(formatter);
try
{
var dbModelHolder = unityContainer.Resolve<DbModelHolder>();
dbModelHolder.ConnectionString =
ConfigurationManager.ConnectionStrings["CommonDbContext"].ConnectionString;
}
catch (Exception e)
{
_logger.Error("dbModelHanlder Configuration failed", e);
}
}
/// <summary>
/// Gets the HTTP response message.
/// </summary>
/// <param name="message">The message.</param>
/// <returns></returns>
private HttpResponseMessage GetHttpResponseMessage(ApiBaseModel message)
{
var httpmessage = new HttpResponseMessage();
var jsonmedia = new JsonMediaTypeFormatter();
httpmessage.Content = new ObjectContent(typeof(ApiBaseModel), message, jsonmedia);
return httpmessage;
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.EnableCors();
var formatter = new JsonMediaTypeFormatter();
// Serialize and deserialize JSON as "myProperty" => "MyProperty" -> "myProperty"
formatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
// Make JSON easier to read for debugging at the expense of larger payloads
formatter.SerializerSettings.Formatting = Formatting.Indented;
// Omit nulls to reduce payload size
formatter.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
// Explicitly define behavior when serializing DateTime values
formatter.SerializerSettings.DateFormatString = "yyyy'-'MM'-'dd'T'HH':'mm':'ssK"; // Only return DateTimes to a 1 second precision.
formatter.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Utc; // Only return UTC for DateTimes values.
// Only support JSON for REST API requests
config.Formatters.Clear();
config.Formatters.Add(formatter);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public BasicUserData GetUser()
{
var builder = new UriBuilder(userInfoBaseUrl)
{
Query = string.Format("access_token={0}", Uri.EscapeDataString(accessToken))
};
var profileClient = new HttpClient();
HttpResponseMessage profileResponse = profileClient.GetAsync(builder.Uri).Result;
var formatter = new JsonMediaTypeFormatter();
formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/javascript"));
var userInfo = profileResponse.Content.ReadAsAsync<JToken>(new[] { formatter }).Result;
return
new BasicUserData
{
UserId = userInfo.Value<string>("id"),
UserName = userInfo.Value<string>("name"),
FirstName = userInfo.Value<string>("given_name"),
LastName = userInfo.Value<string>("family_name"),
PictureUrl = userInfo.Value<string>("picture"),
Email = userInfo.Value<string>("email")
};
}
public bool IsTokenValid()
{
var tokenValidatorUrl = new UriBuilder(tokenValidatorBaseUrl)
{
Query = string.Format("access_token={0}", accessToken)
};
var client = new HttpClient();
HttpResponseMessage validationResponse = client.GetAsync(tokenValidatorUrl.Uri).Result;
var formatter = new JsonMediaTypeFormatter();
formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/javascript"));
var responseData = validationResponse.Content.ReadAsAsync<JToken>(new[] { formatter }).Result;
var error = responseData.Value<string>("error");
var audience = responseData.Value<string>("audience");
//if an error was returned, the token is invalid
if (error != null)
{
return false;
}
//ensure the token is valid for THIS app
else if (audience == null || audience != clientAppId)
{
return false;
}
else
{
return true;
}
}
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 appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
//force json only
var jsonFormatter = new JsonMediaTypeFormatter
{
SerializerSettings =
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
}
};
//optional: set serializer settings here
config.Services.Replace(typeof(IContentNegotiator), new JsonContentNegotiator(jsonFormatter));
config.Formatters.Insert(0, new JsonNetFormatter());
}
/// <inheritdoc />
public virtual void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor)
{
if (controllerSettings == null)
{
throw new ArgumentNullException("controllerSettings");
}
JsonMediaTypeFormatter jsonFormatter = new JsonMediaTypeFormatter();
JsonSerializerSettings serializerSettings = jsonFormatter.SerializerSettings;
// Set up date/time format to be ISO 8601 but with 3 digits and "Z" as UTC time indicator. This format
// is the JS-valid format accepted by most JS clients.
IsoDateTimeConverter dateTimeConverter = new IsoDateTimeConverter()
{
Culture = CultureInfo.InvariantCulture,
DateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFZ",
DateTimeStyles = DateTimeStyles.AdjustToUniversal
};
// Ignoring default values while serializing was affecting offline scenarios as client sdk looks at first object in a batch for the properties.
// If first row in the server response did not include columns with default values, client sdk ignores these columns for the rest of the rows
serializerSettings.DefaultValueHandling = DefaultValueHandling.Include;
serializerSettings.NullValueHandling = NullValueHandling.Include;
serializerSettings.Converters.Add(new StringEnumConverter());
serializerSettings.Converters.Add(dateTimeConverter);
serializerSettings.MissingMemberHandling = MissingMemberHandling.Error;
serializerSettings.CheckAdditionalContent = true;
serializerSettings.ContractResolver = new ServiceContractResolver(jsonFormatter);
controllerSettings.Formatters.Remove(controllerSettings.Formatters.JsonFormatter);
controllerSettings.Formatters.Insert(0, jsonFormatter);
}
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.Filters.Add(new GlobalExceptionFilterAttribute());
var jsonformatter = new JsonMediaTypeFormatter
{
SerializerSettings = ApiJsonSerializerSettings
};
config.Formatters.RemoveAt(0);
config.Formatters.Insert(0, jsonformatter);
//config.Formatters.JsonFormatter.SerializerSettings = ApiJsonSerializerSettings;
config.Formatters.JsonFormatter.SerializerSettings.Error = (object sender, ErrorEventArgs args) =>
{
//errors.Add(args.ErrorContext.Error.Message);
args.ErrorContext.Handled = true;
};
}
public static void Register(HttpConfiguration config) {
//config.EnableCors();
config.MapHttpAttributeRoutes();
//config.EnableCors(new EnableCorsAttribute("*", "*", "*"));
if (config != null) {
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { controller = "Default", method = "Get", id = RouteParameter.Optional }
);
//var jsonFormatter = config.Formatters.OfType<JsonMediaTypeFormatter>().First();
config.Formatters.Clear();
var jsonFormatter = new JsonMediaTypeFormatter();
jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.Add(jsonFormatter);
}
}
// GET api/<num>
public HttpResponseMessage Get(int? id, string extension = "json")
{
var results = GetComputedResults(id);
MediaTypeFormatter fmtr = null;
switch (extension)
{
case "plain-text":
//TODO: write formatter
fmtr = new PlainTextMediaFormatter();
break;
case "xml":
fmtr = new XmlMediaTypeFormatter() { UseXmlSerializer = true };
break;
case "json":
fmtr = new JsonMediaTypeFormatter();
JsonMediaTypeFormatter f = fmtr as JsonMediaTypeFormatter;
break;
}
if (fmtr == null)
{
return new HttpResponseMessage(HttpStatusCode.NotFound);
}
return new HttpResponseMessage()
{
Content = new ObjectContent<FibonacciResultSet>(
results,
fmtr
)
};
}
private static HttpResponseMessage BuildContent(IEnumerable<string> messages)
{
var exceptionMessage = new ExceptionResponse { Messages = messages };
var formatter = new JsonMediaTypeFormatter();
var content = new ObjectContent<ExceptionResponse>(exceptionMessage, formatter, "application/json");
return new HttpResponseMessage { Content = content };
}
public static void Register(HttpConfiguration config)
{
config.MapHttpAttributeRoutes();
var jsonFormatter = new JsonMediaTypeFormatter();
config.Services.Replace(typeof(IContentNegotiator), new JsonContentNegotiator(jsonFormatter));
}
/// <summary>
/// Registers the specified configuration.
/// </summary>
/// <param name="config">The configuration.</param>
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
config.UseOrderedFilter();
JsonMediaTypeFormatter formatter = new JsonMediaTypeFormatter
{
SerializerSettings =
{
NullValueHandling = NullValueHandling.Include,
DateFormatString = "G",
DefaultValueHandling = DefaultValueHandling.Populate,
Formatting = Formatting.None,
ContractResolver = new CamelCasePropertyNamesContractResolver()
}
};
config.Filters.Add(new GlobalExceptionFilterAttribute());
config.Formatters.Clear();
config.Formatters.Add(formatter);
config.EnableCors(new EnableCorsAttribute("*", "*", "GET,POST,PUT,OPTIONS", "*"));
SystemDiagnosticsTraceWriter traceWriter = config.EnableSystemDiagnosticsTracing();
traceWriter.IsVerbose = true;
traceWriter.MinimumLevel = TraceLevel.Info;
// Web API routes
config.MapHttpAttributeRoutes();
}
private static void AddDataControllerFormatters(List<MediaTypeFormatter> formatters, DataControllerDescription description)
{
var cachedSerializers = _serializerCache.GetOrAdd(description.ControllerType, controllerType =>
{
// for the specified controller type, set the serializers for the built
// in framework types
List<SerializerInfo> serializers = new List<SerializerInfo>();
Type[] exposedTypes = description.EntityTypes.ToArray();
serializers.Add(GetSerializerInfo(typeof(ChangeSetEntry[]), exposedTypes));
return serializers;
});
JsonMediaTypeFormatter formatterJson = new JsonMediaTypeFormatter();
formatterJson.SerializerSettings = new JsonSerializerSettings() { PreserveReferencesHandling = PreserveReferencesHandling.Objects, TypeNameHandling = TypeNameHandling.All };
XmlMediaTypeFormatter formatterXml = new XmlMediaTypeFormatter();
// apply the serializers to configuration
foreach (var serializerInfo in cachedSerializers)
{
formatterXml.SetSerializer(serializerInfo.ObjectType, serializerInfo.XmlSerializer);
}
formatters.Add(formatterJson);
formatters.Add(formatterXml);
}
public JsonContentNegotiator()
{
formatter = new JsonMediaTypeFormatter();
// TODO: Make Configurable
formatter.Indent = true;
formatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
GlobalConfiguration.Configuration.Formatters.Clear();
var formatter = new JsonMediaTypeFormatter
{
SerializerSettings =
new JsonSerializerSettings
{
PreserveReferencesHandling =
PreserveReferencesHandling.Objects
}
};
GlobalConfiguration.Configuration.Formatters.Add(formatter);
// OData
var builder = new ODataConventionModelBuilder();
builder.EntitySet<UserDevice>("UserDevice");
builder.EntitySet<UserInformation>("UserInformation");
config.Routes.MapODataRoute("odata", "odata", builder.GetEdmModel());
// Web API routes
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();
config.EnableCors();
var kernel = ApiSetup.CreateKernel();
var resolver = new NinjectDependencyResolver(kernel);
var jsonFormatter = new JsonMediaTypeFormatter();
jsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));
config.Formatters.Add(jsonFormatter);
//setup dependency resolver for API
config.DependencyResolver = resolver;
//setup dependency for UI controllers
//DependencyResolver.SetResolver(resolver.GetService, resolver.GetServices);
foreach (var item in GlobalConfiguration.Configuration.Formatters)
{
if (typeof (JsonMediaTypeFormatter) == item.GetType())
{
item.AddQueryStringMapping("responseType", "json", "application/json");
}
}
}
protected virtual System.Net.Http.HttpResponseMessage GetResponseMessage <T>(string requestUri, T postData)
{
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(ContentType.AsContentTypeString()));
if (AuthenticationMethod == AuthenticationType.OAuth && !string.IsNullOrEmpty(_bearerToken))
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _bearerToken);
}
MediaTypeFormatter mediaFormatter;
if (ContentType == RequestContentType.ApplicationXml)
{
mediaFormatter = new System.Net.Http.Formatting.XmlMediaTypeFormatter();
}
else
{
mediaFormatter = new System.Net.Http.Formatting.JsonMediaTypeFormatter();
}
HttpResponseMessage responseMsg = null;
if (OperationMethod == HttpMethod.Get)
{
responseMsg = client.GetAsync(requestUri).Result;
}
else if (OperationMethod == HttpMethod.Delete && postData == null)
{
responseMsg = client.DeleteAsync(requestUri).Result;
}
else if (OperationMethod == HttpMethod.Head)
{
var rqstMsg = new HttpRequestMessage(HttpMethod.Head, requestUri);
responseMsg = client.SendAsync(rqstMsg).Result;
}
else
{
//Note: Need to explicitly specify the content type here otherwise this call fails.
if (OperationMethod == HttpMethod.Put)
{
responseMsg = client.PutAsync <T>(requestUri, postData, mediaFormatter).Result;
}
else
{
responseMsg = client.PostAsync <T>(requestUri, postData, mediaFormatter).Result;
}
}
return(responseMsg);
}
public static void Main(string[] args)
{
string url = @"http://localhost:10512/api/values";
Person personToPost = new Person {
FirstName = "first name here",
LastName = "last name here",
Id = new Random().Next()
};
var jsonFormatter = new System.Net.Http.Formatting.JsonMediaTypeFormatter();
var mediaType = new MediaTypeHeaderValue("application/json");
var requestMessage = new HttpRequestMessage <Person>(
personToPost,
mediaType,
new MediaTypeFormatter[] { jsonFormatter });
HttpClient client = null;
HttpResponseMessage response = null;
try {
client = new HttpClient();
Task postTask = client.PostAsync(url, requestMessage.Content).ContinueWith(respMsg => {
response = respMsg.Result;
});
postTask.Wait();
Console.WriteLine(string.Format("Response status code: {0}", response.StatusCode));
response.EnsureSuccessStatusCode();
}
catch (Exception ex) {
string message = string.Format("An error occurred: {0}{1}{0}]", Environment.NewLine, ex.Message);
}
finally {
if (client != null)
{
client.Dispose();
client = null;
}
}
Console.WriteLine("Press enter to continue");
Console.ReadLine();
}
static JsonExtensions()
{
System.Net.Http.Formatting.JsonMediaTypeFormatter mediaTypeFormatter1 = new System.Net.Http.Formatting.JsonMediaTypeFormatter();
mediaTypeFormatter1.SerializerSettings = JsonExtensions.ObjectSerializationSettings;
mediaTypeFormatter1.UseDataContractJsonSerializer = false;
JsonExtensions.JsonObjectTypeFormatter = (MediaTypeFormatter)mediaTypeFormatter1;
JsonExtensions.JsonObjectTypeFormatters = new MediaTypeFormatter[1]
{
JsonExtensions.JsonObjectTypeFormatter
};
System.Net.Http.Formatting.JsonMediaTypeFormatter mediaTypeFormatter2 = new System.Net.Http.Formatting.JsonMediaTypeFormatter();
mediaTypeFormatter2.SerializerSettings = JsonExtensions.MediaTypeFormatterSettings;
mediaTypeFormatter2.UseDataContractJsonSerializer = false;
JsonExtensions.JsonMediaTypeFormatter = (MediaTypeFormatter)mediaTypeFormatter2;
JsonExtensions.JsonMediaTypeFormatters = new MediaTypeFormatter[1]
{
JsonExtensions.JsonMediaTypeFormatter
};
}
public override bool Execute()
{
HttpClient client = null;
try {
var jsonFormatter = new System.Net.Http.Formatting.JsonMediaTypeFormatter();
var mediaType = new MediaTypeHeaderValue("application/json");
var jsonSerializerSettings = new JsonSerializerSettings();
var requestMessage = new HttpRequestMessage <string>(
this.PostContent,
mediaType,
new MediaTypeFormatter[] { jsonFormatter });
client = new HttpClient();
HttpResponseMessage response = null;
System.Threading.Tasks.Task postTask = client.PostAsync(this.Url, requestMessage.Content).ContinueWith(respMessage => {
response = respMessage.Result;
});
System.Threading.Tasks.Task.WaitAll(new System.Threading.Tasks.Task[] { postTask });
response.EnsureSuccessStatusCode();
return(true);
}
catch (Exception ex) {
string message = "Unable to post the message.";
throw new LoggerException(message, ex);
}
finally {
if (client != null)
{
client.Dispose();
client = null;
}
}
}
public HttpResponseMessage Get()
{
try
{
var formatter = new JsonMediaTypeFormatter();
var json = formatter.SerializerSettings;
json.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.MicrosoftDateFormat;
json.DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc;
json.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
json.Formatting = Newtonsoft.Json.Formatting.Indented;
json.ContractResolver = new CamelCasePropertyNamesContractResolver();
var categories =
_bhtaEntities.Categories.ToList()
.Select(
m =>
new CategoryModel()
{
Id = m.Id,
Name = m.Name,
Description = m.Description,
Permalink = m.Permalink
});
return Request.CreateResponse(HttpStatusCode.OK, categories, formatter);
}
catch (Exception exception)
{
return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exception.ToString());
}
}
