private static void SetResponseHeaders(ResponseMessage responseMessage, IResponse response) { // Force setting the Date header (#577) AppendResponseHeader( response, HttpKnownHeaderNames.Date, new[] { DateTime.UtcNow.ToString(CultureInfo.InvariantCulture.DateTimeFormat.RFC1123Pattern, CultureInfo.InvariantCulture) }); // Set other headers foreach (var item in responseMessage.Headers) { var headerName = item.Key; var value = item.Value; if (ResponseHeadersToFix.ContainsKey(headerName)) { ResponseHeadersToFix[headerName]?.Invoke(response, value); } else { // Check if this response header can be added (#148 and #227) if (!HttpKnownHeaderNames.IsRestrictedResponseHeader(headerName)) { AppendResponseHeader(response, headerName, value.ToArray()); } } } }
private static void AppendResponseHeader(IResponse response, string headerName, string[] values) { #if !USE_ASPNETCORE response.Headers.AppendValues(headerName, values); #else response.Headers.Append(headerName, values); #endif }
/// <inheritdoc cref="IOwinResponseMapper.MapAsync"/> public async Task MapAsync(ResponseMessage responseMessage, IResponse response) { if (responseMessage == null) { return; } byte[] bytes; switch (responseMessage.FaultType) { case FaultType.EMPTY_RESPONSE: bytes = IsFault(responseMessage) ? new byte[0] : GetNormalBody(responseMessage); break; case FaultType.MALFORMED_RESPONSE_CHUNK: bytes = GetNormalBody(responseMessage) ?? new byte[0]; if (IsFault(responseMessage)) { bytes = bytes.Take(bytes.Length / 2).Union(_randomizerBytes.Generate()).ToArray(); } break; default: bytes = GetNormalBody(responseMessage); break; } var statusCodeType = responseMessage.StatusCode?.GetType(); switch (statusCodeType) { case Type typeAsIntOrEnum when typeAsIntOrEnum == typeof(int) || typeAsIntOrEnum == typeof(int?) || typeAsIntOrEnum.GetTypeInfo().IsEnum: response.StatusCode = MapStatusCode((int)responseMessage.StatusCode); break; case Type typeAsString when typeAsString == typeof(string): // Note: this case will also match on null int.TryParse(responseMessage.StatusCode as string, out int result); response.StatusCode = MapStatusCode(result); break; default: break; } SetResponseHeaders(responseMessage, response); if (bytes != null) { await response.Body.WriteAsync(bytes, 0, bytes.Length); } }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="context"></param> /// <param name="response"></param> /// <param name="request"></param> /// <param name="encoding">Encoding que será usado na reposta.</param> public HttpResponse(HttpContext context, Microsoft.Owin.IOwinResponse response, System.Web.HttpRequestBase request, System.Text.Encoding encoding) { _context = context; _response = response; _request = request; _encoding = encoding; _cookies = new System.Web.HttpCookieCollection(); _headers = new System.Collections.Specialized.NameValueCollection(); _response.OnSendingHeaders(SendHeaders, null); _writer = new HttpResponseWriter(response, encoding); _cache = new HttpCachePolicy(this); ContentType = response.ContentType; }
/// <inheritdoc cref="IOwinResponseMapper.MapAsync"/> public async Task MapAsync(ResponseMessage responseMessage, IResponse response) { if (responseMessage == null) { return; } byte[] bytes; switch (responseMessage.FaultType) { case FaultType.EMPTY_RESPONSE: bytes = IsFault(responseMessage) ? new byte[0] : GetNormalBody(responseMessage); break; case FaultType.MALFORMED_RESPONSE_CHUNK: bytes = GetNormalBody(responseMessage) ?? new byte[0]; if (IsFault(responseMessage)) { bytes = bytes.Take(bytes.Length / 2).Union(_randomizerBytes.Generate()).ToArray(); } break; default: bytes = GetNormalBody(responseMessage); break; } switch (responseMessage.StatusCode) { case int statusCodeAsInteger: response.StatusCode = MapStatusCode(statusCodeAsInteger); break; case string statusCodeAsString: // Note: this case will also match on null int.TryParse(statusCodeAsString, out int result); response.StatusCode = MapStatusCode(result); break; } SetResponseHeaders(responseMessage, response); if (bytes != null) { await response.Body.WriteAsync(bytes, 0, bytes.Length); } }
/// <inheritdoc cref="IOwinResponseMapper.MapAsync"/> public async Task MapAsync(ResponseMessage responseMessage, IResponse response) { if (responseMessage == null) { return; } response.StatusCode = responseMessage.StatusCode; byte[] bytes = null; switch (responseMessage.BodyData?.DetectedBodyType) { case BodyType.String: bytes = (responseMessage.BodyData.Encoding ?? _utf8NoBom).GetBytes(responseMessage.BodyData.BodyAsString); break; case BodyType.Json: Formatting formatting = responseMessage.BodyData.BodyAsJsonIndented == true ? Formatting.Indented : Formatting.None; string jsonBody = JsonConvert.SerializeObject(responseMessage.BodyData.BodyAsJson, new JsonSerializerSettings { Formatting = formatting, NullValueHandling = NullValueHandling.Ignore }); bytes = (responseMessage.BodyData.Encoding ?? _utf8NoBom).GetBytes(jsonBody); break; case BodyType.Bytes: bytes = responseMessage.BodyData.BodyAsBytes; break; case BodyType.File: bytes = _fileSystemHandler.ReadResponseBodyAsFile(responseMessage.BodyData.BodyAsFile); break; } SetResponseHeaders(responseMessage, response); if (bytes != null) { await response.Body.WriteAsync(bytes, 0, bytes.Length); } }
private void SetResponseHeaders(ResponseMessage responseMessage, IResponse response) { // Set headers foreach (var pair in responseMessage.Headers) { if (ResponseHeadersToFix.ContainsKey(pair.Key)) { ResponseHeadersToFix[pair.Key]?.Invoke(response, pair.Value); } else { // Check if this response header can be added (#148 and #227) if (!HttpKnownHeaderNames.IsRestrictedResponseHeader(pair.Key)) { #if !USE_ASPNETCORE response.Headers.AppendValues(pair.Key, pair.Value.ToArray()); #else response.Headers.Append(pair.Key, pair.Value.ToArray()); #endif } } } }
/// <inheritdoc cref="IOwinResponseMapper.MapAsync"/> public async Task MapAsync(ResponseMessage responseMessage, IResponse response) { if (responseMessage == null) { return; } byte[] bytes; switch (responseMessage.FaultType) { case FaultType.EMPTY_RESPONSE: bytes = IsFault(responseMessage) ? new byte[0] : GetNormalBody(responseMessage); break; case FaultType.MALFORMED_RESPONSE_CHUNK: bytes = GetNormalBody(responseMessage) ?? new byte[0]; if (IsFault(responseMessage)) { bytes = bytes.Take(bytes.Length / 2).Union(_randomizerBytes.Generate()).ToArray(); } break; default: bytes = GetNormalBody(responseMessage); break; } response.StatusCode = responseMessage.StatusCode; SetResponseHeaders(responseMessage, response); if (bytes != null) { await response.Body.WriteAsync(bytes, 0, bytes.Length); } }
public HttpResponse(Microsoft.Owin.IOwinResponse response) { _response = response; }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="response"></param> public HttpResponseWriter(Microsoft.Owin.IOwinResponse response, System.Text.Encoding encoding) { _response = response; _encoding = encoding; }