// https://forums.asp.net/t/1773007.aspx?How+to+correctly+use+PostAsync+and+PutAsync+
public string Put <T>(T data)
{
System.Net.Http.Headers.MediaTypeHeaderValue mediaType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
Newtonsoft.Json.JsonSerializerSettings jsonSerializerSettings =
new Newtonsoft.Json.JsonSerializerSettings();
// JsonNetFormatter jsonFormatter = new JsonNetFormatter(jsonSerializerSettings);
// var requestMessage = new
// System.Net.Http.HttpRequestMessage<T>(data, mediaType
// , new System.Net.Http.Formatting.MediaTypeFormatter[] { jsonFormatter });
System.Net.Http.ObjectContent content = new System.Net.Http.ObjectContent <T>(data
, new System.Net.Http.Formatting.JsonMediaTypeFormatter()
);
using (System.Net.Http.HttpClient httpClient = new System.Net.Http.HttpClient())
{
string _endpoint = "";
httpClient.PutAsync(_endpoint, content).ContinueWith(httpResponseMessage =>
{
return(httpResponseMessage.Result.Content.ReadAsStringAsync());
// return await Task.Run(() => httpResponseMessage.Result.Content.ReadAsStringAsync());
});
}
return(null);
}
public WebApiRequestException(string message, System.Net.HttpStatusCode statusCode, string response, System.Net.Http.Headers.HttpResponseHeaders headers, System.Net.Http.Headers.MediaTypeHeaderValue contentType) : base(message)
{
StatusCode = statusCode;
Response = response;
Headers = headers;
ContentType = contentType;
}
public async System.Threading.Tasks.Task <string> Put <T>(string uri, T data)
{
using (System.Net.Http.HttpClient httpClient = new System.Net.Http.HttpClient())
{
System.Net.Http.Headers.MediaTypeHeaderValue mediaType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
Newtonsoft.Json.JsonSerializerSettings jsonSerializerSettings =
new Newtonsoft.Json.JsonSerializerSettings();
JsonNetFormatter jsonFormatter = new JsonNetFormatter(jsonSerializerSettings);
System.Net.Http.ObjectContent content = new System.Net.Http.ObjectContent <T>(data
, new System.Net.Http.Formatting.JsonMediaTypeFormatter()
);
System.Net.Http.HttpResponseMessage response = await httpClient.PutAsync(uri, content);
response.EnsureSuccessStatusCode();
return(response.Content.ReadAsStringAsync().Result);
/*
* var requestMessage = new System.Net.Http.HttpRequestMessage
* (data, mediaType, new System.Net.Http.Formatting.MediaTypeFormatter[] { jsonFormatter });
*
* // var result = httpClient.PutAsync("_endpoint", requestMessage.Content).Result;
* // return result.Content.ReadAsStringAsync().Result;
*/
}
}
public static Encoding GetEncoding(System.Net.Http.Headers.MediaTypeHeaderValue mediaTypeHeaderValue)
{
string charset = mediaTypeHeaderValue?.CharSet;
// If we do have encoding information in the 'Content-Type' header, use that information to convert
// the content to a string.
if (charset != null)
{
try
{
// Remove at most a single set of quotes.
if (charset.Length > 2 &&
charset[0] == '\"' &&
charset[charset.Length - 1] == '\"')
{
return(Encoding.GetEncoding(charset.Substring(1, charset.Length - 2)));
}
else
{
return(Encoding.GetEncoding(charset));
}
}
catch (ArgumentException e)
{
throw new InvalidOperationException("The character set provided in ContentType is invalid. Cannot read content as string using an invalid character set.", e);
}
}
return(null);
}
private static HttpRequestMessage CreateHttpRequestMessage(string uri, Stream requestStream, HttpMethod method,
IHeaderDictionary customHeaders, ILogger log)
{
//Default to JSON content type
HttpContent content = null;
if (requestStream != null)
{
const string DEFAULT_CONTENT_TYPE = ContentTypeConstants.ApplicationJson;
var contentType = MediaTypeHeaderValue.Parse(DEFAULT_CONTENT_TYPE);
if (customHeaders?.ContainsKey(HeaderNames.ContentType) == true)
{
if (MediaTypeHeaderValue.TryParse(customHeaders[HeaderNames.ContentType], out var ct))
{
contentType = ct;
}
else
{
log.LogWarning($"Failed to convert {customHeaders[HeaderNames.ContentType]} to a valid Content-Type.");
}
}
// The content coming in with already be encoded correctly (for strings, via Encoding.UTF8.GetBytes())
content = new StreamContent(requestStream);
content.Headers.ContentType = contentType;
}
return(new HttpRequestMessage(method, uri)
{
Content = content
});
}
public async void ProcessRequest(Microsoft.AspNetCore.Http.HttpContext context)
#endif
{
var request = context.Request;
var response = context.Response;
string result;
try
{
result = this.DoCommand(context);
}
catch (System.Exception ex)
{
result = System.Text.Json.JsonSerializer.Serialize(new Thinksea.Net.FileUploader.Result()
{
ErrorCode = 1,
Message = ex.Message
});
#if DEBUG
System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
}
#if NETFRAMEWORK
response.ContentEncoding = System.Text.Encoding.UTF8;
response.ContentType = "application/json";
response.AddHeader("Pragma", "no-cache");
response.CacheControl = "no-cache";
response.Write(result);
#elif NETCOREAPP
{
if (!response.Headers.ContainsKey(Microsoft.Net.Http.Headers.HeaderNames.Pragma))
{
response.Headers.Add(Microsoft.Net.Http.Headers.HeaderNames.Pragma, "no-cache");
}
//response.CacheControl = "no-store";
if (!response.Headers.ContainsKey(Microsoft.Net.Http.Headers.HeaderNames.CacheControl))
{
response.Headers.Add(Microsoft.Net.Http.Headers.HeaderNames.CacheControl, "no-cache");
}
System.Net.Http.Headers.MediaTypeHeaderValue mediaType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
mediaType.CharSet = "utf-8";
response.ContentType = mediaType.ToString();
using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
{
using (System.IO.StreamWriter sw = new System.IO.StreamWriter(ms, System.Text.Encoding.UTF8))
{
sw.Write(result);
sw.Flush();
ms.Seek(0, System.IO.SeekOrigin.Begin);
await ms.CopyToAsync(response.Body);
}
}
return;
}
#endif
}
public MediaTypeHeaderValue(System.Net.Http.Headers.MediaTypeHeaderValue containedObject)
{
if ((containedObject == null))
{
throw new System.ArgumentNullException("containedObject");
}
this.containedObject = containedObject;
}
/// <inheritdoc/>
public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
{
Type type = context.ObjectType;
if (type == null)
{
throw Error.ArgumentNull("type");
}
type = TypeHelper.GetTaskInnerTypeOrSelf(type);
HttpRequest request = context.HttpContext.Request;
if (request == null)
{
throw Error.InvalidOperation(SRResources.WriteToStreamAsyncMustHaveRequest);
}
HttpResponse response = context.HttpContext.Response;
if (typeof(Stream).IsAssignableFrom(type))
{
// Ideally, it should go into the "ODataRawValueSerializer",
// However, OData lib doesn't provide the method to overwrite/copyto stream
// So, Here's the workaround
Stream objStream = context.Object as Stream;
return(CopyStreamAsync(objStream, response));
}
Uri baseAddress = GetBaseAddressInternal(request);
MediaTypeHeaderValue contentType = GetContentType(response.Headers[HeaderNames.ContentType].FirstOrDefault());
Func <ODataSerializerContext> getODataSerializerContext = () =>
{
return(new ODataSerializerContext()
{
Request = request,
});
};
ODataSerializerProvider serializerProvider = request.GetRequestContainer().GetRequiredService <ODataSerializerProvider>();
return(ODataOutputFormatterHelper.WriteToStreamAsync(
type,
context.Object,
request.GetModel(),
ResultHelpers.GetODataResponseVersion(request),
baseAddress,
contentType,
new WebApiUrlHelper(request.GetUrlHelper()),
new WebApiRequestMessage(request),
new WebApiRequestHeaders(request.Headers),
(services) => ODataMessageWrapperHelper.Create(new StreamWrapper(response.Body), response.Headers, services),
(edmType) => serializerProvider.GetEdmTypeSerializer(edmType),
(objectType) => serializerProvider.GetODataPayloadSerializer(objectType, request),
getODataSerializerContext));
}
public Response HasContentType(Http.Headers.MediaTypeHeaderValue contentType)
{
return(new Response(this.response.Then(response => {
Assert.Equal(contentType, response.Content.Headers.ContentType);
return response;
}))
{
DefaultStatus = this.DefaultStatus
});
}
public ProtobufSerializer(Func <RuntimeTypeModel, RuntimeTypeModel> serializerConfigurator)
{
if (serializerConfigurator == null)
{
throw new ArgumentNullException(nameof(serializerConfigurator));
}
_runtimeTypeModel = serializerConfigurator(TypeModel.Create());
MediaType = MediaTypeHeaderValue.Parse("application/x-protobuf");
}
public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
{
Type type = context.ObjectType;
if (type == null)
{
throw Error.ArgumentNull("type");
}
type = TypeHelper.GetTaskInnerTypeOrSelf(type);
HttpRequest request = context.HttpContext.Request;
if (request == null)
{
throw Error.InvalidOperation(SRResources.WriteToStreamAsyncMustHaveRequest);
}
try
{
HttpResponse response = context.HttpContext.Response;
Uri baseAddress = GetBaseAddressInternal(request);
MediaTypeHeaderValue contentType = GetContentType(response.Headers[HeaderNames.ContentType].FirstOrDefault());
Func <ODataSerializerContext> getODataSerializerContext = () =>
{
return(new ODataSerializerContext()
{
Request = request,
});
};
ODataSerializerProvider serializerProvider = request.GetRequestContainer().GetRequiredService <ODataSerializerProvider>();
ODataOutputFormatterHelper.WriteToStream(
type,
context.Object,
request.GetModel(),
ResultHelpers.GetODataResponseVersion(request),
baseAddress,
contentType,
new WebApiUrlHelper(request.GetUrlHelper()),
new WebApiRequestMessage(request),
new WebApiRequestHeaders(request.Headers),
(services) => ODataMessageWrapperHelper.Create(response.Body, response.Headers, services),
(edmType) => serializerProvider.GetEdmTypeSerializer(edmType),
(objectType) => serializerProvider.GetODataPayloadSerializer(objectType, request),
getODataSerializerContext);
return(TaskHelpers.Completed());
}
catch (Exception ex)
{
return(TaskHelpers.FromError(ex));
}
}
/// <inheritdoc/>
public override void WriteResponseHeaders(OutputFormatterWriteContext context)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
Type type = context.ObjectType;
if (type == null)
{
throw Error.ArgumentNull("type");
}
type = TypeHelper.GetTaskInnerTypeOrSelf(type);
HttpRequest request = context.HttpContext.Request;
if (request == null)
{
throw Error.InvalidOperation(SRResources.WriteToStreamAsyncMustHaveRequest);
}
HttpResponse response = context.HttpContext.Response;
response.ContentType = context.ContentType.Value;
MediaTypeHeaderValue contentType = GetContentType(response.Headers[HeaderNames.ContentType].FirstOrDefault());
// Determine the content type.
MediaTypeHeaderValue newMediaType = null;
if (ODataOutputFormatterHelper.TryGetContentHeader(type, contentType, out newMediaType))
{
response.Headers[HeaderNames.ContentType] = new StringValues(newMediaType.ToString());
}
// Set the character set.
MediaTypeHeaderValue currentContentType = GetContentType(response.Headers[HeaderNames.ContentType].FirstOrDefault());
RequestHeaders requestHeader = request.GetTypedHeaders();
if (requestHeader != null && requestHeader.AcceptCharset != null)
{
IEnumerable <string> acceptCharsetValues = requestHeader.AcceptCharset.Select(cs => cs.Value.Value);
string newCharSet = string.Empty;
if (ODataOutputFormatterHelper.TryGetCharSet(currentContentType, acceptCharsetValues, out newCharSet))
{
currentContentType.CharSet = newCharSet;
response.Headers[HeaderNames.ContentType] = new StringValues(currentContentType.ToString());
}
}
// Add version header.
response.Headers[ODataVersionConstraint.ODataServiceVersionHeader] = ODataUtils.ODataVersionToString(ResultHelpers.GetODataResponseVersion(request));
}
internal static void SetFileSettings(string fileName, HttpResponseMessage response, String contentType)
{
var mt = new System.Net.Http.Headers.MediaTypeHeaderValue(contentType);
var con = new System.Net.Http.Headers.ContentDispositionHeaderValue("attachment")
{
FileName = fileName
};
response.Content.Headers.ContentType = mt;
response.Content.Headers.ContentDisposition = con;
}
private MediaTypeHeaderValue GetContentType(string contentTypeValue)
{
MediaTypeHeaderValue contentType = null;
if (!string.IsNullOrEmpty(contentTypeValue))
{
MediaTypeHeaderValue.TryParse(contentTypeValue, out contentType);
}
return(contentType);
}
public static async Task <IHttpResponse> CreateContentFormAsync(
[Property(Name = ContentIdPropertyName)] Guid contentId,
[Property(Name = ContentPropertyName)] byte[] contentBytes,
[Header(Content = ContentPropertyName)] System.Net.Http.Headers.MediaTypeHeaderValue mediaHeader,
CreatedResponse onCreated,
AlreadyExistsResponse onAlreadyExists)
{
var contentType = mediaHeader.MediaType;
return(await EastFive.Api.Azure.Content.CreateContentAsync(contentId, contentType, contentBytes,
() => onCreated(),
() => onAlreadyExists()));
}
public async Task <HttpResponseMessage> RunResetAccountForm(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "auth/reset")] HttpRequest req,
ExecutionContext context,
ILogger log)
{
log.LogInformation($"#auth #reset");
string filePath = Path.Combine(context.FunctionDirectory, "../Templates/ResetPasswordForm.html");
var response = new HttpResponseMessage(HttpStatusCode.OK);
var stream = new FileStream(filePath, FileMode.Open);
response.Content = new StreamContent(stream);
response.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("text/html");
return(response);
}
protected override async Task <HttpResponseMessage> SendAsync(
HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request.Content != null && !string.IsNullOrEmpty(_options.RequestContentType))
{
request.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(_options.RequestContentType);
}
await SignRequest(request);
var response = await base.SendAsync(request, cancellationToken);
ValidateResponse(response);
return(response);
}
public HttpResponseMessage Download(string fileType, string folder)
{
var fullPath = Path.Combine(Config.Configuration.WorkingDirectory, "Editor", folder);
var downloadFileName = "document.pdf";
var documentFileName = Path.Combine(Config.Configuration.WorkingDirectory, "Editor", folder, downloadFileName);
var contentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/pdf");
switch (fileType)
{
case "docx":
downloadFileName = "document.docx";
contentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/vnd.openxmlformats-officedocument.wordprocessingml.document");
break;
case "svg":
downloadFileName = "document.svg";
contentType = new System.Net.Http.Headers.MediaTypeHeaderValue("image/svg+xml");
break;
case "xps":
downloadFileName = "document.xps";
contentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/oxps, application/vnd.ms-xpsdocument");
break;
case "xls":
downloadFileName = "document.xlsx";
contentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
break;
case "html":
downloadFileName = "document.html";
contentType = new System.Net.Http.Headers.MediaTypeHeaderValue("text/html");
break;
}
documentFileName = string.Format("{0}\\{1}", fullPath, downloadFileName);
var dataBytes = File.ReadAllBytes(documentFileName);
var dataStream = new MemoryStream(dataBytes);
HttpResponseMessage httpResponseMessage = Request.CreateResponse(HttpStatusCode.OK);
httpResponseMessage.Content = new StreamContent(dataStream);
httpResponseMessage.Content.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("attachment");
httpResponseMessage.Content.Headers.ContentDisposition.FileName = downloadFileName;
httpResponseMessage.Content.Headers.ContentType = contentType;
return(httpResponseMessage);
}
public AcceptHeaderAttribute(string contentType, params string[] otherContentTypes)
{
if (contentType == null)
{
throw new ArgumentNullException(nameof(contentType));
}
// We want to ensure that the given provided content types are valid values, so
// we validate them using the semantics of MediaTypeHeaderValue.
MediaTypeHeaderValue.Parse(contentType);
for (var i = 0; i < otherContentTypes.Length; i++)
{
MediaTypeHeaderValue.Parse(otherContentTypes[i]);
}
ContentTypes = GetContentTypes(contentType, otherContentTypes);
}
static Http.Headers.MediaTypeHeaderValue GetContentType(string path)
{
Http.Headers.MediaTypeHeaderValue result;
switch (path.Split(new [] { "." }, StringSplitOptions.RemoveEmptyEntries).Last())
{
default: result = null; break;
case "json": result = new Http.Headers.MediaTypeHeaderValue("application/json")
{
CharSet = "utf-8"
}; break;
case "txt": result = new Http.Headers.MediaTypeHeaderValue("text/plain")
{
CharSet = "utf-8"
}; break;
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="args"></param>
/// <param name="context"></param>
/// <param name="connection"></param>
/// <returns></returns>
public async Task ProcessResponse(MsgHandlerEventArgs args, HttpContext context, IConnection connection)
{
if (args.Message.Reply != null)
{
_log.LogTrace($"Create response to reply {args.Message.Reply}");
if (context.Response.Body.CanSeek)
{
context.Response.Body.Position = 0;
}
var response = new HttpResponseMessage
{
StatusCode = (HttpStatusCode)context.Response.StatusCode,
Content = new StreamContent(context.Response.Body),
};
response.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(context.Response.ContentType);
response.Content.Headers.ContentLength = context.Response.Body.Length;
foreach (var header in context.Response.Headers)
{
response.Headers.TryAddWithoutValidation(header.Key, header.Value.AsEnumerable());
}
var content = new HttpMessageContent(response);
var bytes = await content.ReadAsByteArrayAsync();
_log.LogTrace($"Send response to reply {args.Message.Reply}");
connection.Publish(args.Message.Reply, bytes);
_log.LogTrace($"Response to reply {args.Message.Reply} sended");
}
else
{
_log.LogTrace($"reply is empty, response not be sended. request url {context.Request.GetDisplayUrl()}");
}
}
/// <summary>
/// Define os cabeçalhos de conteúdo padrão.
/// </summary>
/// <param name="type"></param>
/// <param name="headers"></param>
/// <param name="mediaType"></param>
public override void SetDefaultContentHeaders(System.Type type, System.Net.Http.Headers.HttpContentHeaders headers, System.Net.Http.Headers.MediaTypeHeaderValue mediaType)
{
base.SetDefaultContentHeaders(type, headers, mediaType);
headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
}
/// <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, System.Net.Http.HttpRequestMessage request, System.Net.Http.Headers.MediaTypeHeaderValue mediaType)
{
var qryParams = System.Web.HttpUtility.ParseQueryString(request.RequestUri.Query);
string loadAttributes = qryParams["LoadAttributes"] ?? string.Empty;
// if "simple" or True is specified in the LoadAttributes param, tell the formatter to serialize in Simple mode
SerializeInSimpleMode = loadAttributes.Equals("simple", StringComparison.OrdinalIgnoreCase) || (loadAttributes.AsBooleanOrNull() ?? false);
// if either "simple", "expanded", or True is specified in the LoadAttributes param, tell the formatter to load the attributes on the way out
LoadAttributes = SerializeInSimpleMode || loadAttributes.Equals("expanded", StringComparison.OrdinalIgnoreCase);
return(base.GetPerRequestFormatterInstance(type, request, mediaType));
}
/// <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, System.Net.Http.HttpRequestMessage request, System.Net.Http.Headers.MediaTypeHeaderValue mediaType)
{
var qryParams = System.Web.HttpUtility.ParseQueryString(request.RequestUri.Query);
string loadAttributes = qryParams["LoadAttributes"] ?? string.Empty;
string[] limitToAttributeKeyList = qryParams["AttributeKeys"]?.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(a => a.Trim()).ToArray();
// if "simple" or True is specified in the LoadAttributes param, tell the formatter to serialize in Simple mode
bool serializeInSimpleMode = loadAttributes.Equals("simple", StringComparison.OrdinalIgnoreCase) || (loadAttributes.AsBooleanOrNull() ?? false);
// if either "simple", "expanded", or True is specified in the LoadAttributes param, tell the formatter to load the attributes on the way out
bool loadAttributesEnabled = serializeInSimpleMode || loadAttributes.Equals("expanded", StringComparison.OrdinalIgnoreCase);
Rock.Model.Person person = null;
// NOTE: request.Properties["Person"] gets set in Rock.Rest.Filters.SecurityAttribute.OnActionExecuting
if (loadAttributesEnabled && request.Properties.ContainsKey("Person"))
{
person = request.Properties["Person"] as Rock.Model.Person;
}
// store the request options in HttpContext.Current.Items so they are thread safe, and only for this request
var loadAttributesOptions = new LoadAttributesOptions(loadAttributesEnabled, serializeInSimpleMode, limitToAttributeKeyList, person);
HttpContext.Current.Items[LoadAttributesOptions.ContextItemsKey] = loadAttributesOptions;
return(base.GetPerRequestFormatterInstance(type, request, mediaType));
}
public static System.Net.Http.Json.JsonContent Create(object inputValue, System.Type inputType, System.Net.Http.Headers.MediaTypeHeaderValue mediaType = default(System.Net.Http.Headers.MediaTypeHeaderValue), System.Text.Json.JsonSerializerOptions options = default(System.Text.Json.JsonSerializerOptions)) => throw null;
public JsonContent(object model) : base(JsonSerializer.SerializeToUtf8Bytes(model))
{
Headers.ContentType = MediaTypeHeaderValue.Parse("application/json");
}
internal static object GetBoundary(System.Net.Http.Headers.MediaTypeHeaderValue mediaTypeHeaderValue, int defaultMultipartBoundaryLengthLimit)
{
throw new NotImplementedException();
}
/// <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, System.Net.Http.HttpRequestMessage request, System.Net.Http.Headers.MediaTypeHeaderValue mediaType)
{
var qryParams = System.Web.HttpUtility.ParseQueryString(request.RequestUri.Query);
string loadAttributes = qryParams["LoadAttributes"] ?? string.Empty;
// if "simple" or True is specified in the LoadAttributes param, tell the formatter to serialize in Simple mode
SerializeInSimpleMode = loadAttributes.Equals("simple", StringComparison.OrdinalIgnoreCase) || (loadAttributes.AsBooleanOrNull() ?? false);
// if either "simple", "expanded", or True is specified in the LoadAttributes param, tell the formatter to load the attributes on the way out
LoadAttributes = SerializeInSimpleMode || loadAttributes.Equals("expanded", StringComparison.OrdinalIgnoreCase);
// NOTE: request.Properties["Person"] gets set in Rock.Rest.Filters.SecurityAttribute.OnActionExecuting
if (LoadAttributes && request.Properties.ContainsKey("Person"))
{
this.Person = request.Properties["Person"] as Rock.Model.Person;
}
return(base.GetPerRequestFormatterInstance(type, request, mediaType));
}
public override MediaTypeFormatter GetPerRequestFormatterInstance(Type type, System.Net.Http.HttpRequestMessage request, System.Net.Http.Headers.MediaTypeHeaderValue mediaType)
{
string callback;
if (request.GetQueryNameValuePairs().ToDictionary(pari => pari.Key, pari => pari.Value).TryGetValue("callback", out callback))
{
return(new JsonpMediaTypeFormatter(callback));
}
return(this);
}
public override void SetDefaultContentHeaders(Type type, System.Net.Http.Headers.HttpContentHeaders headers, System.Net.Http.Headers.MediaTypeHeaderValue mediaType)
{
base.SetDefaultContentHeaders(type, headers, mediaType);
headers.ContentType.CharSet = null;
}
