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; } } }
/// <summary> /// Returns a specialized instance of the <see cref="T:System.Net.Http.Formatting.MediaTypeFormatter"/> that can format a response for the given parameters. /// </summary> /// <param name="type">The type to format.</param> /// <param name="request">The request.</param> /// <param name="mediaType">The media type.</param> /// <returns>Returns <see cref="T:System.Net.Http.Formatting.MediaTypeFormatter"/>.</returns> public override MediaTypeFormatter GetPerRequestFormatterInstance(Type type, HttpRequestMessage request, MediaTypeHeaderValue mediaType) { var parameters = request.RequestUri.ParseQueryString(); var prettify = false; if (parameters[PrettifyParameterName] != null) { prettify = new[] { "yes", "1", "true" }.Contains(parameters[PrettifyParameterName], StringComparer.OrdinalIgnoreCase); } var fieldNamingStratgey = _fieldNamingStratgey; if (parameters[FieldNamingStrategyParameterName] != null) { switch (parameters[FieldNamingStrategyParameterName]) { case "none": fieldNamingStratgey = new DefaultFieldNamingStrategy(); break; case "dash": fieldNamingStratgey = new DasherizedFieldNamingStrategy(); break; case "snake": fieldNamingStratgey = new SnakeCaseNamingStrategy(); break; } } return new JsonApiMediaTypeFormatter(ContractResolver, fieldNamingStratgey, prettify); }
public override MediaTypeFormatter GetPerRequestFormatterInstance(Type type, HttpRequestMessage request,MediaTypeHeaderValue mediaType) { //所需的对象属性 var includingFields = request.GetRouteData().Values["fields"]; if (includingFields != null && !string.IsNullOrEmpty(includingFields.ToString())) { FieldsJsonMediaTypeFormatter frmtr = new FieldsJsonMediaTypeFormatter(); frmtr.CurrentRequest = request; var resolve = new Share.IncludableSerializerContractResolver(this.SerializerSettings.ContractResolver as Share.IgnorableSerializerContractResolver); //type.IsAssignableFrom(typeof(IEnumerable<Model.dr_pre_visit>)) if (type.GetInterface("IEnumerable") != null) { resolve.Include(type.GenericTypeArguments[0], includingFields.ToString(), ','); } else { resolve.Include(type, includingFields.ToString(), ","); } frmtr.SerializerSettings = new JsonSerializerSettings { ContractResolver = resolve, }; return frmtr; } else { return this; } }
/// <summary> /// Creates a new <see cref="HelpPageSampleKey"/> based on media type, <see cref="SampleDirection"/>, controller name, action name and parameter names. /// </summary> /// <param name="mediaType">The media type.</param> /// <param name="sampleDirection">The <see cref="SampleDirection"/>.</param> /// <param name="controllerName">Name of the controller.</param> /// <param name="actionName">Name of the action.</param> /// <param name="parameterNames">The parameter names.</param> public HelpPageSampleKey(MediaTypeHeaderValue mediaType, SampleDirection sampleDirection, string controllerName, string actionName, IEnumerable<string> parameterNames) { if (mediaType == null) { throw new ArgumentNullException("mediaType"); } if (!Enum.IsDefined(typeof(SampleDirection), sampleDirection)) { throw new InvalidEnumArgumentException("sampleDirection", (int)sampleDirection, typeof(SampleDirection)); } if (controllerName == null) { throw new ArgumentNullException("controllerName"); } if (actionName == null) { throw new ArgumentNullException("actionName"); } if (parameterNames == null) { throw new ArgumentNullException("parameterNames"); } ControllerName = controllerName; ActionName = actionName; MediaType = mediaType; ParameterNames = new HashSet<string>(parameterNames, StringComparer.OrdinalIgnoreCase); SampleDirection = sampleDirection; }
public TypedJsonMediaTypeFormatter(Type resourceType, MediaTypeHeaderValue mediaType) { this.resourceType = resourceType; this.SupportedMediaTypes.Clear(); this.SupportedMediaTypes.Add(mediaType); }
public override void SetDefaultContentHeaders(Type type, HttpContentHeaders headers, MediaTypeHeaderValue mediaType) { base.SetDefaultContentHeaders(type, headers, mediaType); // Remove charset parameter. It must not be sent according to Json Api (http://jsonapi.org/format/#content-negotiation-servers) headers.ContentType.CharSet = null; }
public StringResponseWriter(string text, MediaTypeHeaderValue contentType) { VerifyArgument.IsNotNull("mediaType", contentType); _text = text; _contentType = contentType; _enforceSizeCap = true; }
protected virtual string MakeCachekey(HttpActionContext context, MediaTypeHeaderValue mediaType, bool excludeQueryString = false) { var controller = context.ControllerContext.ControllerDescriptor.ControllerName; var action = context.ActionDescriptor.ActionName; var key = context.Request.GetConfiguration().CacheOutputConfiguration().MakeBaseCachekey(controller, action); var parametersCollections = context.ActionArguments.Where(x => x.Value != null).Select(x => x.Key + "=" + x.Value); var parameters = "-"+string.Join("&", parametersCollections); if (excludeQueryString) { parameters = string.Empty; } else { var callbackValue = GetJsonpCallback(context.Request); if (!string.IsNullOrWhiteSpace(callbackValue)) { var callback = "callback=" + callbackValue; if (parameters.Contains("&" + callback)) parameters = parameters.Replace("&" + callback, string.Empty); if (parameters.Contains(callback + "&")) parameters = parameters.Replace(callback + "&", string.Empty); if (parameters.Contains("-" + callback)) parameters = parameters.Replace("-" + callback, string.Empty); if (parameters.EndsWith("&")) parameters = parameters.TrimEnd('&'); } } if (parameters == "-") parameters = string.Empty; var cachekey = string.Format("{0}{1}:{2}", key, parameters, mediaType.MediaType); return cachekey; }
public FileRepresentationModel(string filename, string fileExtension, byte[] contentAsByteArray, MediaTypeHeaderValue mediaTypeHeaderValue) { Filename = filename; FileExtension = fileExtension; ContentAsByteArray = contentAsByteArray; MediaTypeHeaderValue = mediaTypeHeaderValue; }
public static MapRepresentation Create(IOidStrategy oidStrategy, HttpRequestMessage req, ContextFacade contextFacade, IList<ContextFacade> contexts, Format format, RestControlFlags flags, MediaTypeHeaderValue mt) { var memberValues = contexts.Select(c => new OptionalProperty(c.Id, GetMap(oidStrategy, req, c, flags))).ToList(); IObjectFacade target = contexts.First().Target; MapRepresentation mapRepresentation; if (format == Format.Full) { var tempProperties = new List<OptionalProperty>(); if (!string.IsNullOrEmpty(contextFacade?.Reason)) { tempProperties.Add(new OptionalProperty(JsonPropertyNames.XRoInvalidReason, contextFacade.Reason)); } var dt = new OptionalProperty(JsonPropertyNames.DomainType, target.Specification.DomainTypeName(oidStrategy)); tempProperties.Add(dt); var members = new OptionalProperty(JsonPropertyNames.Members, Create(memberValues.ToArray())); tempProperties.Add(members); mapRepresentation = Create(tempProperties.ToArray()); } else { mapRepresentation = Create(memberValues.ToArray()); } mapRepresentation.SetContentType(mt); return mapRepresentation; }
public override void SetDefaultContentHeaders(Type type, HttpContentHeaders headers, MediaTypeHeaderValue mediaType) { base.SetDefaultContentHeaders(type, headers, mediaType); headers.ContentType = new MediaTypeHeaderValue(ApplicationJsonMediaType); this.SerializerSettings.Formatting = Formatting.None; this.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); }
public ParsedMediaTypeHeaderValue(MediaTypeHeaderValue mediaType) { this.mediaType = mediaType; string[] splitMediaType = mediaType.MediaType.Split(MediaTypeSubTypeDelimiter); this.type = splitMediaType[0]; this.subType = splitMediaType[1]; }
public OpenSearchDescription(MediaTypeHeaderValue contentType, Stream stream) : this(XDocument.Load(stream)) { //if (contentType.MediaType != "application/opensearchdescription+xml") //{ // throw new NotSupportedException("Do not understand " + contentType.MediaType + " as a search description language"); //} }
public override void OnActionExecuting(HttpActionContext context) { if (context == null) { throw new ArgumentNullException("actionContext"); } else if (this.IsCacheable(context)) { cachekey = string.Join(":", context.Request.RequestUri.AbsolutePath, context.Request.Headers.Accept.FirstOrDefault().ToString()); if (WebApiOutputCacheAttribute.webApiCache.Contains(this.cachekey)) { var val = WebApiOutputCacheAttribute.webApiCache.Get(this.cachekey) as string; if (val != null) { var contenttype = WebApiOutputCacheAttribute.webApiCache.Get(cachekey + ":response-ct") as MediaTypeHeaderValue; if (contenttype == null) { contenttype = new MediaTypeHeaderValue(this.cachekey.Split(':')[1]); } context.Response = context.Request.CreateResponse(); context.Response.Content = new StringContent(val); context.Response.Content.Headers.ContentType = contenttype; context.Response.Headers.CacheControl = this.SetClientCache(); return; } } } }
public override MediaTypeFormatter GetPerRequestFormatterInstance(Type type, HttpRequestMessage request, MediaTypeHeaderValue mediaType) { if (_viewLocator == null || _viewParser == null) { var config = request.GetConfiguration(); if (config != null) { IViewLocator viewLocator = null; IViewParser viewParser = null; var resolver = config.DependencyResolver; if (_viewLocator == null) viewLocator = (IViewLocator) resolver.GetService(typeof (IViewLocator)); if (_viewParser == null) viewParser = (IViewParser) resolver.GetService(typeof (IViewParser)); return new HtmlMediaTypeViewFormatter(_siteRootPath, viewLocator, viewParser); } } return base.GetPerRequestFormatterInstance(type, request, mediaType); }
public static MapRepresentation Create(HttpRequestMessage req, IList<ContextSurface> contexts, Format format, RestControlFlags flags, MediaTypeHeaderValue mt) { OptionalProperty[] memberValues = contexts.Select(c => new OptionalProperty(c.Id, GetMap(req, c, flags))).ToArray(); INakedObjectSurface target = contexts.First().Target; MapRepresentation mapRepresentation; if (format == Format.Full) { var tempProperties = new List<OptionalProperty>(); if (flags.SimpleDomainModel) { var dt = new OptionalProperty(JsonPropertyNames.DomainType, target.Specification.DomainTypeName()); tempProperties.Add(dt); } if (flags.FormalDomainModel) { var links = new OptionalProperty(JsonPropertyNames.Links, new[] { Create(new OptionalProperty(JsonPropertyNames.Rel, RelValues.DescribedBy), new OptionalProperty(JsonPropertyNames.Href, new UriMtHelper(req, target.Specification).GetDomainTypeUri())) }); tempProperties.Add(links); } var members = new OptionalProperty(JsonPropertyNames.Members, Create(memberValues)); tempProperties.Add(members); mapRepresentation = Create(tempProperties.ToArray()); } else { mapRepresentation = Create(memberValues); } mapRepresentation.SetContentType(mt); return mapRepresentation; }
public override void OnActionExecuting(HttpActionContext ac) { if (ac != null) { if (_isCacheable(ac)) { _cachekey = string.Join(":", new string[] { ac.Request.RequestUri.AbsolutePath, ac.Request.Headers.Accept.FirstOrDefault().ToString() }); if (WebApiCache.Contains(_cachekey)) { var val = (string)WebApiCache.Get(_cachekey); if (val != null) { var contenttype = (MediaTypeHeaderValue)WebApiCache.Get(_cachekey + ":response-ct"); if (contenttype == null) contenttype = new MediaTypeHeaderValue(_cachekey.Split(':')[1]); ac.Response = ac.Request.CreateResponse(); ac.Response.Content = new StringContent(val); ac.Response.Content.Headers.ContentType = contenttype; ac.Response.Headers.CacheControl = setClientCache(); return; } } } } else { throw new ArgumentNullException("actionContext"); } }
public void Negotiate_ForRequestReturnsFirstMatchingFormatter() { MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("application/myMediaType"); MediaTypeFormatter formatter1 = new MockMediaTypeFormatter() { CanWriteTypeCallback = (Type t) => false }; MediaTypeFormatter formatter2 = new MockMediaTypeFormatter() { CanWriteTypeCallback = (Type t) => true }; formatter2.SupportedMediaTypes.Add(mediaType); MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection( new MediaTypeFormatter[] { formatter1, formatter2 }); _request.Content = new StringContent("test", Encoding.Default, mediaType.MediaType); var result = _negotiator.Negotiate(typeof(string), _request, collection); Assert.Same(formatter2, result.Formatter); Assert.MediaType.AreEqual(mediaType, result.MediaType, "Expected the formatter's media type to be returned."); }
public static MapRepresentation Create(HttpRequestMessage req, ContextSurface context, Format format, RestControlFlags flags, MediaTypeHeaderValue mt) { var objectContextSurface = context as ObjectContextSurface; var actionResultContextSurface = context as ActionResultContextSurface; MapRepresentation mapRepresentation; if (objectContextSurface != null) { List<OptionalProperty> optionalProperties = objectContextSurface.VisibleProperties.Where(p => p.Reason != null || p.ProposedValue != null).Select(c => new OptionalProperty(c.Id, GetMap(req, c, flags))).ToList(); if (!string.IsNullOrEmpty(objectContextSurface.Reason)) { optionalProperties.Add(new OptionalProperty(JsonPropertyNames.XRoInvalidReason, objectContextSurface.Reason)); } mapRepresentation = Create(optionalProperties.ToArray()); } else if (actionResultContextSurface != null) { List<OptionalProperty> optionalProperties = actionResultContextSurface.ActionContext.VisibleParameters.Select(c => new OptionalProperty(c.Id, GetMap(req, c, flags))).ToList(); if (!string.IsNullOrEmpty(actionResultContextSurface.Reason)) { optionalProperties.Add(new OptionalProperty(JsonPropertyNames.XRoInvalidReason, actionResultContextSurface.Reason)); } mapRepresentation = Create(optionalProperties.ToArray()); } else { mapRepresentation = GetMap(req, context, flags); } mapRepresentation.SetContentType(mt); return mapRepresentation; }
public void Constructor(string queryStringParameterName, string queryStringParameterValue, MediaTypeHeaderValue mediaType) { QueryStringMapping mapping = new QueryStringMapping(queryStringParameterName, queryStringParameterValue, mediaType); Assert.Equal(queryStringParameterName, mapping.QueryStringParameterName); Assert.Equal(queryStringParameterValue, mapping.QueryStringParameterValue); Assert.MediaType.AreEqual(mediaType, mapping.MediaType, "MediaType failed to set."); }
public void Equals_Returns_True_If_MediaTypes_Differ_Only_By_Case() { MediaTypeHeaderValueEqualityComparer comparer = MediaTypeHeaderValueEqualityComparer.EqualityComparer; MediaTypeHeaderValue mediaType1 = new MediaTypeHeaderValue("text/xml"); MediaTypeHeaderValue mediaType2 = new MediaTypeHeaderValue("TEXT/xml"); Assert.IsTrue(comparer.Equals(mediaType1, mediaType2), "Equals should have returned 'true'."); mediaType1 = new MediaTypeHeaderValue("text/*"); mediaType2 = new MediaTypeHeaderValue("TEXT/*"); Assert.IsTrue(comparer.Equals(mediaType1, mediaType2), "Equals should have returned 'true'."); mediaType1 = new MediaTypeHeaderValue("*/*"); mediaType2 = new MediaTypeHeaderValue("*/*"); Assert.IsTrue(comparer.Equals(mediaType1, mediaType2), "Equals should have returned 'true'."); mediaType1 = new MediaTypeHeaderValue("text/*"); mediaType1.CharSet = "someCharset"; mediaType2 = new MediaTypeHeaderValue("TEXT/*"); mediaType2.CharSet = "SOMECHARSET"; Assert.IsTrue(comparer.Equals(mediaType1, mediaType2), "Equals should have returned 'true'."); mediaType1 = new MediaTypeHeaderValue("application/*"); mediaType1.CharSet = ""; mediaType2 = new MediaTypeHeaderValue("application/*"); mediaType2.CharSet = null; Assert.IsTrue(comparer.Equals(mediaType1, mediaType2), "Equals should have returned 'true'."); }
/// <summary> /// Sets the sample request directly for the specified media type of the action. /// </summary> /// <param name="config">The <see cref="HttpConfiguration" />.</param> /// <param name="sample">The sample response.</param> /// <param name="mediaType">The media type.</param> /// <param name="controllerName">Name of the controller.</param> /// <param name="actionName">Name of the action.</param> public static void SetSampleResponse(this HttpConfiguration config, object sample, MediaTypeHeaderValue mediaType, string controllerName, string actionName) { config.GetHelpPageSampleGenerator() .ActionSamples.Add( new HelpPageSampleKey(mediaType, SampleDirection.Response, controllerName, actionName, new[] {"*"}), sample); }
/// <summary> /// Constructor which initializes this serializer /// </summary> public JsonSerializer() { ContentType = new MediaTypeHeaderValue("application/json") { CharSet = _encoding.WebName, }; }
///<summary> /// Creates a file parameter from an array of bytes. ///</summary> ///<param name="name">The parameter name to use in the request.</param> ///<param name="input">The input stream for the file's contents.</param> ///<param name="filename">The filename to use in the request.</param> ///<param name="contentType">The content type to use in the request.</param> ///<returns>The <see cref="FileParameter"/></returns> public static FileParameter Create(string name, Stream input, string filename, MediaTypeHeaderValue contentType) { var temp = new MemoryStream(); input.CopyTo(temp); var data = temp.ToArray(); return Create(name, data, filename, contentType); }
public void Ctor_MediaTypeValidFormat_SuccessfullyCreated() { MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/plain"); Assert.Equal("text/plain", mediaType.MediaType); Assert.Equal(0, mediaType.Parameters.Count); Assert.Null(mediaType.CharSet); }
public RouteDataMapping(string routeDataValueName, string routeDataValueValue, MediaTypeHeaderValue mediaType) : base(mediaType) { _routeDataValueName = routeDataValueName; _routeDataValueValue = routeDataValueValue; }
public static HttpContentType CreateFromBase64(HttpContentHeaderData headerData, string base64) { var content = CreateBase64(base64); content.Headers.ContentType = HttpMediaTypeHeaderValue.Parse(headerData.ContentType); return(content); }
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: "GetStringAPI", routeTemplate: "api/{controller}/{category}/{query}", defaults: new { category = "getmovielist", query = RouteParameter.Optional } ); config.Routes.MapHttpRoute( name: "GetblockListAPI", routeTemplate: "api/{controller}/{category}/{id}", defaults: new { category = "getblocklist", id = RouteParameter.Optional } ); config.Routes.MapHttpRoute( name: "GetblockQueryAPI", routeTemplate: "api/{controller}/{category}/{query}", defaults: new { category = "getblocklist", id = RouteParameter.Optional } ); System.Net.Http.Headers.MediaTypeHeaderValue appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml"); config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType); config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html")); }
private static MediaTypeHeaderValue GetContentTypeFromQueryString(IEdmModel model, Type type, string dollarFormat) { var formatters = CreateOutputFormatters(model); var path = new ODataPath(); var request = string.IsNullOrEmpty(dollarFormat) ? RequestFactory.CreateFromModel(model, "http://any", "OData", path) : RequestFactory.CreateFromModel(model, "http://any/?$format=" + dollarFormat, "OData", path); var context = new OutputFormatterWriteContext( request.HttpContext, new TestHttpResponseStreamWriterFactory().CreateWriter, type, new MemoryStream()); foreach (var formatter in formatters) { context.ContentType = new StringSegment(); context.ContentTypeIsServerDefined = false; if (formatter.CanWriteResult(context)) { MediaTypeHeaderValue mediaType = MediaTypeHeaderValue.Parse(context.ContentType.ToString()); // We don't care what the charset is for these tests. if (mediaType.Parameters.Where(p => p.Name == "charset").Any()) { mediaType.Parameters.Remove(mediaType.Parameters.Single(p => p.Name == "charset")); } return(mediaType); } } return(null); }
public async Task Download(HttpResponseMessage httpResponseMessage, int id, string field, Database.Sqlite db) { string filename = httpResponseMessage.Content.Headers.ContentDisposition.FileName.Replace("\"", ""); System.Net.Http.Headers.MediaTypeHeaderValue contenttype = httpResponseMessage.Content.Headers.ContentType; using (Stream stream = await httpResponseMessage.Content.ReadAsStreamAsync()) { using (MemoryStream ms = new MemoryStream()) { //string filename = $"{docid}_{(int)type}"; stream.CopyTo(ms); byte[] buffer = ms.ToArray(); stream.Flush(); if (filename == "404.json") { filename = httpResponseMessage.RequestMessage.RequestUri.ToString(); } else { int year = 20 * 100 + id / 100000000; SaveFile(buffer, filename, year); db.UpdateFilenameOfDisclosure(id, field, filename); } #pragma warning disable CS4014 SaveLog(GetLog(httpResponseMessage.StatusCode, RequestType.Archive, contenttype, filename)); #pragma warning restore CS4014 } } httpResponseMessage.Dispose(); }
public void GetMediaType_HandlesUnknownMediaTypes(string extension) { MediaTypeMap map = new MediaTypeMap(); MediaTypeHeaderValue expectedMediaType = new MediaTypeHeaderValue("application/octet-stream"); Assert.Equal(expectedMediaType, map.GetMediaType(extension)); }
public async Task <ArchiveResponse> DownloadArchive(string docid, DocumentType type, int retry) { ArchiveResponse response = new ArchiveResponse(); string url = string.Format("/api/{0}/documents/{1}?type={2}", Version, docid, (int)type); int i = 0; do { if (i > 0) { SaveLog($" retry[{i}] {docid} {type}"); Debug.Write($"retry Download[{i}] "); await Task.Delay(2000); } try { debug.ProgramCodeInfo.SetDebugQueue(); using (HttpResponseMessage res = await client.GetAsync(url)) { debug.ProgramCodeInfo.SetDebugQueue(); string filename = res.Content.Headers.ContentDisposition.FileName.Replace("\"", ""); //string filename = $"{docid}_{(int)type}"; System.Net.Http.Headers.MediaTypeHeaderValue contenttype = res.Content.Headers.ContentType; if (filename == "404.json") { filename = url; } #pragma warning disable CS4014 SaveLog(GetLog(res.StatusCode, RequestType.Archive, contenttype, filename)); #pragma warning restore CS4014 using (Stream stream = await res.Content.ReadAsStreamAsync()) { using (MemoryStream ms = new MemoryStream()) { stream.CopyTo(ms); byte[] buffer = ms.ToArray(); stream.Flush(); response.Update(buffer, res.StatusCode, filename, contenttype); debug.ProgramCodeInfo.SetDebugQueue(); return(response); } } } } catch (TaskCanceledException ex) { response.Update(ex); #pragma warning disable CS4014 SaveLog(GetLog(response)); #pragma warning restore CS4014 debug.ProgramCodeInfo.SetDebugQueue(); } catch (Exception ex) { response.Update(ex); #pragma warning disable CS4014 SaveLog(GetLog(response)); #pragma warning restore CS4014 debug.ProgramCodeInfo.SetDebugQueue(); return(response); } i++; } while (i <= retry); return(response); }
public void TestCreate_Property_DefaultContentType() { // Arrange IEdmModel model = CreateModelWithEntity <SampleType>(); Type propertyType = typeof(int); // Act MediaTypeHeaderValue mediaType = GetDefaultContentType(model, propertyType); // Assert Assert.Equal(MediaTypeHeaderValue.Parse("application/json;odata.metadata=minimal;odata.streaming=true"), mediaType); }
public void TestCreate_MetadataDocument_DollarFormat(string dollarFormatValue, string expectedMediaType) { // Arrange IEdmModel model = CreateModel(); Type metadataDocumentType = typeof(IEdmModel); // Act MediaTypeHeaderValue mediaType = GetContentTypeFromQueryString(model, metadataDocumentType, dollarFormatValue); // Assert Assert.Equal(MediaTypeHeaderValue.Parse(expectedMediaType), mediaType); }
public void TestCreate_MetadataDocument_DefaultContentType() { // Arrange IEdmModel model = CreateModel(); Type serviceDocumentType = typeof(IEdmModel); // Act MediaTypeHeaderValue mediaType = GetDefaultContentType(model, serviceDocumentType); // Assert Assert.Equal(MediaTypeHeaderValue.Parse("application/xml"), mediaType); }
public void TestCreate_DollarFormat_Collection(string dollarFormatValue, string expectedMediaType) { // Arrange IEdmModel model = CreateModelWithEntity <SampleType>(); Type collectionType = typeof(IEnumerable <int>); // Act MediaTypeHeaderValue mediaType = GetContentTypeFromQueryString(model, collectionType, dollarFormatValue); // Assert Assert.Equal(MediaTypeHeaderValue.Parse(expectedMediaType), mediaType); }
public void TestCreate_DollarFormat_Error(string dollarFormatValue, string expectedMediaType) { // Arrange IEdmModel model = CreateModelWithEntity <SampleType>(); Type errorType = typeof(ODataError); // Act MediaTypeHeaderValue mediaType = GetContentTypeFromQueryString(model, errorType, dollarFormatValue); // Assert Assert.Equal(MediaTypeHeaderValue.Parse(expectedMediaType), mediaType); }
public void TestCreate_ServiceDocument_DefaultContentType() { // Arrange IEdmModel model = CreateModel(); Type serviceDocumentType = typeof(ODataServiceDocument); // Act MediaTypeHeaderValue mediaType = GetDefaultContentType(model, serviceDocumentType); // Assert Assert.Equal(MediaTypeHeaderValue.Parse("application/json;odata.metadata=minimal;odata.streaming=true"), mediaType); }
private Stream Serialize <T>(System.Net.Http.Formatting.MediaTypeFormatter formatter, T value, System.Net.Http.Headers.MediaTypeHeaderValue mediaType) { Stream stream = new MemoryStream(); try { HttpContent content = new StreamContent(stream); content.Headers.ContentType = mediaType; formatter.WriteToStreamAsync(typeof(T), value, stream, content, null).Wait(); stream.Position = 0; } catch (Exception ex) { Console.WriteLine("Serialization error: " + ex.ToString()); } return(stream); }
//Content-Type: multipart/form-data; boundary="----WebKitFormBoundarymx2fSWqWSd0OxQqq" // The spec at https://tools.ietf.org/html/rfc2046#section-5.1 states that 70 characters is a reasonable limit. public static string GetBoundary(System.Net.Http.Headers.MediaTypeHeaderValue contentType, int lengthLimit) { string boundary = "----WebKitFormBoundarymx2fSWqWSd0OxQqq"; //string boundary = HeaderUtilities.RemoveQuotes().Value; if (string.IsNullOrWhiteSpace(boundary)) { throw new InvalidDataException("Missing content-type boundary."); } if (boundary.Length > lengthLimit) { throw new InvalidDataException( $"Multipart boundary length limit {lengthLimit} exceeded."); } return(boundary); }
public static HttpContentType CreateFromBody(HttpContentHeaderData headerData, string body) { if (headerData.ContentEncoding == "gzip") { var content = CreateGzip(body); content.Headers.ContentType = HttpMediaTypeHeaderValue.Parse(headerData.ContentType); #if WINDOWS_UWP content.Headers.ContentEncoding.ParseAdd(headerData.ContentEncoding); #else content.Headers.ContentEncoding.Add(headerData.ContentEncoding); #endif return(content); } else { var content = CreateString(body); content.Headers.ContentType = HttpMediaTypeHeaderValue.Parse(headerData.ContentType); return(content); } }
public override void SetDefaultContentHeaders(Type type, HttpContentHeaders headers, MediaTypeHeaderValue mediaType) { string fileName; // Look for ExcelDocumentAttribute on class. var itemType = util.GetEnumerableItemType(type); var excelDocumentAttribute = util.GetAttribute <ExcelDocumentAttribute>(itemType ?? type); if (excelDocumentAttribute != null && !string.IsNullOrEmpty(excelDocumentAttribute.FileName)) { // If attribute exists with file name defined, use that. fileName = excelDocumentAttribute.FileName; } else { // Otherwise, use "data". fileName = "data"; } // Add XLSX extension if not present. if (!fileName.EndsWith("xlsx", StringComparison.CurrentCultureIgnoreCase)) { fileName += ".xlsx"; } // Set content disposition to use this file name. headers.ContentDisposition = new ContentDispositionHeaderValue("inline") { FileName = fileName }; base.SetDefaultContentHeaders(type, headers, mediaType); }
private static IEnumerable <MediaTypeHeaderValue> GetMediaTypes(string[] mediaTypes) { return(mediaTypes.Select(m => MediaTypeHeaderValue.Parse(m))); }
internal static object GetBoundary(System.Net.Http.Headers.MediaTypeHeaderValue mediaTypeHeaderValue, object multipartBoundaryLengthLimit) { throw new NotImplementedException(); }
/// <summary> /// Validate HttpResponse message, throws an Api Exception with context /// </summary> /// <param name="response"></param> /// <param name="request"></param> /// <param name="apiContext"></param> /// <exception cref="ApiException"></exception> public static void EnsureSuccess(HttpResponseMessage response, HttpRequestMessage request=null, IApiContext apiContext=null) { if (response.IsSuccessStatusCode) return; if (response.StatusCode == HttpStatusCode.NotModified) return; var content = response.Content.ReadAsStringAsync().Result; ApiException exception ; var htmlMediaType = new MediaTypeHeaderValue("text/html"); if (response.Content.Headers.ContentType != null && response.Content.Headers.ContentType.MediaType == htmlMediaType.MediaType) { var message = String.Format("Status Code {0}, Uri - {1}", response.StatusCode, response.RequestMessage.RequestUri.AbsoluteUri); exception = new ApiException(message, new Exception(content)); } else if (!String.IsNullOrEmpty(content)) exception = JsonConvert.DeserializeObject<ApiException>(content); else if (HttpStatusCode.NotFound == response.StatusCode && string.IsNullOrEmpty(content) && request != null) exception = new ApiException("Uri "+request.RequestUri.AbsoluteUri + " does not exist"); else exception = new ApiException("Unknow Exception"); exception.HttpStatusCode = response.StatusCode; exception.CorrelationId = HttpHelper.GetHeaderValue(Headers.X_VOL_CORRELATION, response.Headers); exception.ApiContext = apiContext; if (!MozuConfig.ThrowExceptionOn404 && string.Equals(exception.ErrorCode, "ITEM_NOT_FOUND", StringComparison.OrdinalIgnoreCase) && response.RequestMessage.Method.Method == "GET") return; throw exception; }
/// <summary> /// Creates a new <see cref="HelpPageSampleKey" /> based on media type and CLR type. /// </summary> /// <param name="mediaType">The media type.</param> /// <param name="type">The CLR type.</param> public HelpPageSampleKey(MediaTypeHeaderValue mediaType, Type type) : this(mediaType) { if (type == null) throw new ArgumentNullException("type"); this.ParameterType = type; }
/// <summary> /// Sets the sample request directly for the specified media type and action with parameters. /// </summary> /// <param name="config">The <see cref="HttpConfiguration" />.</param> /// <param name="sample">The sample request.</param> /// <param name="mediaType">The media type.</param> /// <param name="controllerName">Name of the controller.</param> /// <param name="actionName">Name of the action.</param> /// <param name="parameterNames">The parameter names.</param> public static void SetSampleRequest(this HttpConfiguration config, object sample, MediaTypeHeaderValue mediaType, string controllerName, string actionName, params string[] parameterNames) { config.GetHelpPageSampleGenerator() .ActionSamples.Add( new HelpPageSampleKey(mediaType, SampleDirection.Request, controllerName, actionName, parameterNames), sample); }