public static RaygunRequestMessage Build(HttpRequestMessage request, RaygunRequestMessageOptions options)
{
var message = new RaygunRequestMessage();
options = options ?? new RaygunRequestMessageOptions();
message.HostName = request.RequestUri.Host;
message.Url = request.RequestUri.AbsolutePath;
message.HttpMethod = request.Method.ToString();
message.IPAddress = GetIPAddress(request);
message.Form = ToDictionary(request.GetQueryNameValuePairs(), options.IsFormFieldIgnored);
message.QueryString = ToDictionary(request.GetQueryNameValuePairs(), s => false);
SetHeaders(message, request, options.IsHeaderIgnored);
if (!options.IsRawDataIgnored)
{
string contentType = null;
if (message.Headers != null && message.Headers.Contains("Content-Type"))
{
contentType = (string)message.Headers["Content-Type"];
}
if (contentType == null || CultureInfo.InvariantCulture.CompareInfo.IndexOf(contentType, "application/x-www-form-urlencoded", CompareOptions.IgnoreCase) < 0)
{
object body;
if (request.Properties.TryGetValue(RaygunWebApiDelegatingHandler.RequestBodyKey, out body))
{
message.RawData = body.ToString();
}
}
}
return message;
}
protected async override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request.Headers.Authorization != null)
{
if (string.Equals(request.Headers.Authorization.Scheme, AuthenticationType, StringComparison.InvariantCultureIgnoreCase))
{
string authToken = request.Headers.Authorization.Parameter;
// validate Token here
HandleAuthData(request, authToken);
}
} else // try query string parameters to find token
{
var authTokenFound = request.GetQueryNameValuePairs()
.Any(k => k.Key == QueryStringAuthHolderKey);
if (authTokenFound)
{
var tokenKvp = request.GetQueryNameValuePairs()
.First(k => k.Key == QueryStringAuthHolderKey);
HandleAuthData(request, tokenKvp.Value);
}
}
var innerResult = await base.SendAsync(request, cancellationToken);
return innerResult;
}
/// <summary>
/// The parseQueryStringParameters method parses the string and sets some fields according to the result
/// </summary>
/// <param name="request">The request parameter</param>
/// <param name="controller">The controller parameter</param>
private void ParseQueryStringParameters(HttpRequestMessage request, AnetApiController controller)
{
var queryStringPairs = request.GetQueryNameValuePairs();
foreach (var pair in queryStringPairs)
{
switch (pair.Key)
{
case Constants.QueryParameters.Fields:
this.ParseDataShapingParameters(controller, pair);
break;
case Constants.QueryParameters.Offset:
this.ParsePageParameters(controller, pair);
break;
case Constants.QueryParameters.Limit:
this.ParsePageParameters(controller, pair);
break;
case Constants.QueryParameters.PageSize:
this.ParsePageParameters(controller, pair);
break;
case Constants.QueryParameters.PageNumber:
this.ParsePageParameters(controller, pair);
break;
case Constants.QueryParameters.SortKey:
this.ParseSortParameters(controller, pair);
break;
case Constants.QueryParameters.SortOrder:
this.ParseSortParameters(controller, pair);
break;
case Constants.QueryParameters.Filter:
this.ParseFilterParameters(controller, pair);
break;
}
}
}
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
var response = await base.SendAsync(request, cancellationToken);
if(!response.IsSuccessStatusCode)
{
// There was an error earlier in the pipeline so we just return the result as normal
return response;
}
var content = response.Content as ObjectContent;
if (content == null || content.Value == null)
{
// There is no object model for us to manipulate so there is nothing we can do.
return response;
}
var requestedFields = _queryStringParser.GetRequestedFields(request.GetQueryNameValuePairs());
if(!requestedFields.Any())
{
// The client has not specified any fields so just return the entire response to them as normal.
return response;
}
var model = CreateDynamicObject(content.Value);
FilterFields(model, requestedFields);
var filteredResponse = request.CreateResponse(model);
foreach (var header in response.Headers)
{
filteredResponse.Headers.Add(header.Key, header.Value);
}
return filteredResponse;
}
private static string GetApiKeyFromQueryString(HttpRequestMessage request)
{
return request.GetQueryNameValuePairs()
.Where(pair => pair.Key == "apikey")
.Select(pair => pair.Value)
.FirstOrDefault();
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataQueryOptions"/> class based on the incoming request and some metadata information from
/// the <see cref="ODataQueryContext"/>.
/// </summary>
/// <param name="context">The <see cref="ODataQueryContext"/> which contains the <see cref="IEdmModel"/> and some type information</param>
/// <param name="request">The incoming request message</param>
public ODataQueryOptions(ODataQueryContext context, HttpRequestMessage request)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
if (request == null)
{
throw Error.ArgumentNull("request");
}
// remember the context
Context = context;
// Parse the query from request Uri
RawValues = new ODataRawQueryOptions();
IEnumerable<KeyValuePair<string, string>> queryParameters = request.GetQueryNameValuePairs();
foreach (KeyValuePair<string, string> kvp in queryParameters)
{
switch (kvp.Key)
{
case "$filter":
RawValues.Filter = kvp.Value;
ThrowIfEmpty(kvp.Value, "$filter");
Filter = new FilterQueryOption(kvp.Value, context);
break;
case "$orderby":
RawValues.OrderBy = kvp.Value;
ThrowIfEmpty(kvp.Value, "$orderby");
OrderBy = new OrderByQueryOption(kvp.Value, context);
break;
case "$top":
RawValues.Top = kvp.Value;
ThrowIfEmpty(kvp.Value, "$top");
Top = new TopQueryOption(kvp.Value, context);
break;
case "$skip":
RawValues.Skip = kvp.Value;
ThrowIfEmpty(kvp.Value, "$skip");
Skip = new SkipQueryOption(kvp.Value, context);
break;
case "$select":
RawValues.Select = kvp.Value;
break;
case "$inlinecount":
RawValues.InlineCount = kvp.Value;
break;
case "$expand":
RawValues.Expand = kvp.Value;
break;
case "$skiptoken":
RawValues.SkipToken = kvp.Value;
break;
default:
// we don't throw if we can't recognize the query
break;
}
}
}
public override bool Match(
HttpRequestMessage request,
IHttpRoute route,
string parameterName,
IDictionary<string, object> values,
HttpRouteDirection routeDirection)
{
foreach (string key in HeaderConstraints.Keys)
{
if (!request.Headers.Contains(key)
|| string.Compare(request.Headers.GetValues(key).FirstOrDefault(), HeaderConstraints[key].ToString(), true) != 0)
{
return false;
}
}
var queries = request.GetQueryNameValuePairs().ToDictionary(p => p.Key, p => p.Value);
foreach (var key in QueryStringConstraints.Keys)
{
if (!queries.ContainsKey(key)
|| string.Compare(queries[key], QueryStringConstraints[key].ToString(), true) != 0)
{
return false;
}
}
return base.Match(request, route, parameterName, values, routeDirection);
}
public async Task<FlowRequest> ReadGetAsync(HttpRequestMessage request)
{
Dictionary<string, string> dictionary = request.GetQueryNameValuePairs()
.ToDictionary(x => x.Key, x => x.Value);
return Create(dictionary);
}
public string[] ExtractSortExpressions(HttpRequestMessage requestMessage)
{
var queryParams = requestMessage.GetQueryNameValuePairs();
var sortParam = queryParams.FirstOrDefault(kvp => kvp.Key == SortQueryParamKey);
if (sortParam.Key != SortQueryParamKey) return new string[] {};
return sortParam.Value.Split(',');
}
/// <summary>
/// Add OAuth 1.0 Authorization Header to the request
/// </summary>
public override async Task AddOAuthHeader(HttpRequestMessage request)
{
// Try to get token result from request. If not found make call to Gateway to get the token.
if (!this.TryGetTokenResultFromHeader(out tokenResult))
{
this.tokenResult = await this.GetTokenResultAsync();
}
if(this.tokenResult == null || this.tokenResult.Properties == null)
{
Logger.LogError(request, false, "Token result or properties returned are null");
throw new UnauthorizedAccessException(CommonResource.AccessTokenNotFound);
}
if (!this.tokenResult.Properties.ContainsKey("AccessToken"))
{
Logger.LogError(request, false, "Couldn't find AccessToken in OAuth TokenResult.");
throw new UnauthorizedAccessException(CommonResource.AccessTokenNotFound);
}
if (!this.tokenResult.Properties.ContainsKey("ConsumerKey"))
{
Logger.LogError(request, false, "Couldn't find ConsumerKey in OAuth TokenResult.");
throw new UnauthorizedAccessException(CommonResource.AccessTokenInvalid);
}
if (!this.tokenResult.Properties.ContainsKey("AccessTokenSecret"))
{
Logger.LogError(request, false, "Couldn't find AccessTokenSecret in OAuth TokenResult.");
throw new UnauthorizedAccessException(CommonResource.AccessTokenInvalid);
}
Dictionary<string, string> arguments = new Dictionary<string, string>();
foreach (KeyValuePair<string, string> pair in request.GetQueryNameValuePairs())
{
if (!string.IsNullOrEmpty(pair.Value))
{
arguments.Add(pair.Key, pair.Value);
}
}
Uri baseUrl = new Uri(request.RequestUri.GetLeftPart(UriPartial.Path));
string nonce = GenerateNonce();
string timestamp = GenerateTimestamp();
string signature = await this.GenerateSignature(request.Method, baseUrl, nonce, timestamp, arguments);
string authHeader = string.Format(CultureInfo.InvariantCulture,
AuthHeaderFormatOAuth1,
Uri.EscapeDataString(this.tokenResult.Properties["AccessToken"]),
Uri.EscapeDataString(nonce),
Uri.EscapeDataString(this.tokenResult.Properties["ConsumerKey"]),
Uri.EscapeDataString(HashAlgorithm),
Uri.EscapeDataString(timestamp),
Uri.EscapeDataString(Version),
Uri.EscapeDataString(signature));
request.Headers.Add(AuthorizationHeader, authHeader);
}
private static string GetQueryValue(HttpRequestMessage request)
{
var pair = request.GetQueryNameValuePairs()
.FirstOrDefault(kvp => kvp.Key.ToUpperInvariant().Equals(PartialResponseQueryParameterKey));
return object.Equals(pair, default(System.Collections.Generic.KeyValuePair<string,string>))
? null
: pair.Value;
}
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken)
{
// the fall back language
var langauges = new List<StringWithQualityHeaderValue>();
// Check the AcceptLanguage simulated header in the query string first. This will ignore lettercase.
NameValueCollection query = request.GetQueryNameValuePairs()
.Aggregate(new NameValueCollection(), (col, kvp) =>
{
col.Add(kvp.Key, kvp.Value);
return col;
});
if (query[FallbackHeaderConstants.AcceptLanguage] != null)
{
langauges.Add(new StringWithQualityHeaderValue(query[FallbackHeaderConstants.AcceptLanguage], 1.0));
}
else if (request.Headers.AcceptLanguage != null)
{
// then check the Accept-Language header.
langauges.AddRange(request.Headers.AcceptLanguage);
}
langauges = langauges.OrderByDescending(l => l.Quality).ToList();
// this is the final fall-back culture.
var culture = CultureInfo.DefaultThreadCurrentCulture;
var uiCulture = CultureInfo.DefaultThreadCurrentUICulture;
// try to break and find one language that's available
foreach (StringWithQualityHeaderValue lang in langauges)
{
try
{
culture = CultureInfo.GetCultureInfo(lang.Value);
uiCulture = culture;
break;
}
catch (CultureNotFoundException)
{
// ignore the error
}
}
if (_setThreadCulture)
{
Thread.CurrentThread.CurrentCulture = culture ?? _lastResortFallback;
}
if (_setThreadUiCulture)
{
Thread.CurrentThread.CurrentUICulture = uiCulture ?? _lastResortFallback;
}
return base.SendAsync(request, cancellationToken);
}
public override MediaTypeFormatter GetPerRequestFormatterInstance(Type type, HttpRequestMessage request, MediaTypeHeaderValue mediaType)
{
var pairs = request.GetQueryNameValuePairs();
if (pairs.Any(p => p.Key == "envelope" && p.Value == "false"))
{
return jsonMediaTypeFormatter;
}
return envelopeJsonMediaTypeFormatter;
}
private void from_url(HttpRequestMessage request)
{
var items =
request.GetQueryNameValuePairs().Where(q => q.Key == "connection_id").ToList();
if (items.Any())
{
update_last_seen(items.First().Value);
}
}
private static string VersionFromApiKey(HttpRequestMessage request)
{
foreach (var param in request.GetQueryNameValuePairs())
{
if (param.Key.ToLower() == "api_key")
return param.Value;
}
return "2.0";
}
public HttpRequestDetails(HttpRequestMessage message, RaygunRequestMessageOptions options = null)
{
options = options ?? new RaygunRequestMessageOptions();
RequestUri = message.RequestUri;
Method = message.Method;
Form = ToDictionary(message.GetQueryNameValuePairs(), options.IsFormFieldIgnored);
IPAddress = GetIPAddress(message);
SetHeadersAndRawData(message, options.IsHeaderIgnored);
}
private NameValueCollection ParseQueryString(Uri uri)
{
HttpRequestMessage request = new HttpRequestMessage { RequestUri = uri };
NameValueCollection nameValuePairs = new NameValueCollection();
foreach (KeyValuePair<string, string> keyValuePair in request.GetQueryNameValuePairs())
{
nameValuePairs.Add(keyValuePair.Key, keyValuePair.Value);
}
return nameValuePairs;
}
private static string GetPassword(HttpRequestMessage request)
{
IEnumerable<string> values;
if (request.Headers.TryGetValues("password", out values))
return values.FirstOrDefault();
return request.GetQueryNameValuePairs().Where(
kv => string.Equals(kv.Key, "password", StringComparison.OrdinalIgnoreCase))
.Select(kv => kv.Value).FirstOrDefault();
}
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);
}
private bool IgnoreCache(HttpRequestMessage request)
{
var result = false;
var parms = request.GetQueryNameValuePairs().ToDictionary(x => x.Key.ToLower(), x => x.Value);
if (parms.ContainsKey("ignorecache"))
{
Boolean.TryParse(parms["ignorecache"], out result);
}
return result;
}
public static string GetQueryString(HttpRequestMessage request, string key)
{
var queryStrings = request.GetQueryNameValuePairs();
if (queryStrings == null)
return null;
var match = queryStrings.FirstOrDefault(kv => string.Compare(kv.Key, key, true) == 0);
if (string.IsNullOrEmpty(match.Value))
return null;
return match.Value;
}
public HttpResponseMessage Companies(HttpRequestMessage request)
{
var service = new ODataService();
var result = service.Execute(Company.GetCompanies(), request.GetQueryNameValuePairs());
var response = request.CreateResponse();
response.Content = new StringContent(result.Results.ToString(), Encoding.UTF8, "application/json");
return response;
// alternatively, we could change the return type to object and do:
// return JObject.Parse(result.Results.ToString());
// this is necessary (for now) since WebApi wants to be the one to do the serialization
}
bool IHttpRouteConstraint.Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
{
var queries = request.GetQueryNameValuePairs().ToDictionary(p => p.Key, p => p.Value);
foreach (var key in QueryStringConstraints.Keys)
{
if (!queries.ContainsKey(key)
|| string.Compare(queries[key], QueryStringConstraints[key].ToString(), true, CultureInfo.CurrentCulture) != 0)
{
return false;
}
}
return true;
}
public RaygunWebApiRequestMessage(HttpRequestMessage request, RaygunRequestMessageOptions options = null)
{
options = options ?? new RaygunRequestMessageOptions();
HostName = request.RequestUri.Host;
Url = request.RequestUri.AbsolutePath;
HttpMethod = request.Method.ToString();
IPAddress = GetIPAddress(request);
Form = ToDictionary(request.GetQueryNameValuePairs(), options.IsFormFieldIgnored);
SetHeadersAndRawData(request, options.IsHeaderIgnored);
}
public override MediaTypeFormatter GetPerRequestFormatterInstance(Type type, HttpRequestMessage request, MediaTypeHeaderValue mediaType)
{
if (request.Method != HttpMethod.Get)
{
return this;
}
string callback;
if (request.GetQueryNameValuePairs().ToDictionary(pair => pair.Key, pair => pair.Value).TryGetValue("callback", out callback))
{
return new JsonpMediaTypeFormatter(callback);
}
return this;
}
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
bool IsRequestCultureSet = false;
bool IsRequestGlobalCultureSet = false;
string locale = request.GetQueryNameValuePairs().SingleOrDefault(kvp => kvp.Key == "locale").Value;
// try setting locale from query string
if (_supportedLocales.Any(kvp => kvp.Key == locale))
{
SetCulture(request, _supportedLocales.FirstOrDefault(i => i.Key == locale).Value);
}
// try setting it from accept-language header
else
{
foreach (var lang in request.Headers.AcceptLanguage)
{
if (_supportedLocales.Any(kvp => kvp.Key == lang.Value))
{
SetCulture(request, lang.Value);
IsRequestCultureSet = true;
break;
}
}
if (!IsRequestCultureSet)
{
foreach (var lang in request.Headers.AcceptLanguage)
{
var globalLang = lang.Value.Substring(0, 2);
if (_supportedLocales.Any(t => t.Key.StartsWith(globalLang)))
{
SetCulture(request, _supportedLocales.FirstOrDefault(i => i.Key.StartsWith(globalLang)).Value);
IsRequestGlobalCultureSet = true;
break;
}
}
}
if (!IsRequestGlobalCultureSet && !IsRequestCultureSet)
{
SetCulture(request, DEFAULT_CULTURE);
}
}
var response = await base.SendAsync(request, cancellationToken);
return response;
}
internal static AuthorizationLevel GetAuthorizationLevel(HttpRequestMessage request, SecretManager secretManager, string functionName = null)
{
// TODO: Add support for validating "EasyAuth" headers
// first see if a key value is specified via headers or query string (header takes precidence)
IEnumerable<string> values;
string keyValue = null;
if (request.Headers.TryGetValues(FunctionsKeyHeaderName, out values))
{
keyValue = values.FirstOrDefault();
}
else
{
var queryParameters = request.GetQueryNameValuePairs().ToDictionary(p => p.Key, p => p.Value, StringComparer.OrdinalIgnoreCase);
queryParameters.TryGetValue("code", out keyValue);
}
if (!string.IsNullOrEmpty(keyValue))
{
// see if the key specified is the master key
HostSecrets hostSecrets = secretManager.GetHostSecrets();
if (!string.IsNullOrEmpty(hostSecrets.MasterKey) &&
SecretEqual(keyValue, hostSecrets.MasterKey))
{
return AuthorizationLevel.Admin;
}
// see if the key specified matches the host function key
if (!string.IsNullOrEmpty(hostSecrets.FunctionKey) &&
SecretEqual(keyValue, hostSecrets.FunctionKey))
{
return AuthorizationLevel.Function;
}
// if there is a function specific key specified try to match against that
if (functionName != null)
{
FunctionSecrets functionSecrets = secretManager.GetFunctionSecrets(functionName);
if (functionSecrets != null &&
!string.IsNullOrEmpty(functionSecrets.Key) &&
SecretEqual(keyValue, functionSecrets.Key))
{
return AuthorizationLevel.Function;
}
}
}
return AuthorizationLevel.Anonymous;
}
private string GetJsonpCallback(HttpRequestMessage request)
{
var callback = string.Empty;
if (request.Method == HttpMethod.Get)
{
var query = request.GetQueryNameValuePairs();
if (query != null)
{
var queryVal = query.FirstOrDefault(x => x.Key.ToLower() == "callback");
if (!queryVal.Equals(default(KeyValuePair<string, string>))) callback = queryVal.Value;
}
}
return callback;
}
protected override bool Match(TestTarget target, HttpRequestMessage request)
{
_tags = _tags ?? (_tags = target.ResolveDependency(TestDefinition.TestType)
.IfTypeIs<IHaveTags>()
.Then(test =>
{
var tags = test.Tags;
TestDefinition.Tags = tags;
return tags;
})
.ElseDefault()
.OrEmpty()
.ToArray());
return DoTestsMatchFilterRequest(_tags, request.GetQueryNameValuePairs().ToArray());
}
public JsonQueryOptions( HttpRequestMessage request)
{
if (request == null)
{
throw new Exception("request is null");
}
// remember the context and request
Request = request;
// Parse the query from request Uri
RawValues = new RawQueryOptions();
IEnumerable<KeyValuePair<string, string>> queryParameters = request.GetQueryNameValuePairs();
foreach (KeyValuePair<string, string> kvp in queryParameters)
{
switch (kvp.Key)
{
case "$where":
RawValues.Where = kvp.Value;
ThrowIfEmpty(kvp.Value, "$where");
Where = new FilterQueryOption(kvp.Value);
break;
case "$orderby":
RawValues.OrderBy = kvp.Value;
ThrowIfEmpty(kvp.Value, "$orderby");
OrderBy = new OrderByQueryOption(kvp.Value);
break;
case "$top":
RawValues.Top = kvp.Value;
ThrowIfEmpty(kvp.Value, "$top");
Top = new TopQueryOption(kvp.Value);
break;
case "$skip":
RawValues.Skip = kvp.Value;
ThrowIfEmpty(kvp.Value, "$skip");
Skip = new SkipQueryOption(kvp.Value, RawValues);
break;
case "$skiptoken":
RawValues.SkipToken = kvp.Value;
break;
default:
// we don't throw if we can't recognize the query
break;
}
}
}
public HttpResponseMessage Get(HttpRequestMessage request)
{
Tracing.Information("Simple HTTP endpoint called.");
var query = request.GetQueryNameValuePairs();
var auth = new AuthenticationHelper();
var realm = query.FirstOrDefault(p => p.Key.Equals("realm", System.StringComparison.OrdinalIgnoreCase)).Value;
var tokenType = query.FirstOrDefault(p => p.Key.Equals("tokenType", System.StringComparison.OrdinalIgnoreCase)).Value;
if (string.IsNullOrWhiteSpace(realm))
{
return request.CreateErrorResponse(HttpStatusCode.BadRequest, "realm parameter is missing.");
}
EndpointReference appliesTo;
try
{
appliesTo = new EndpointReference(realm);
Tracing.Information("Simple HTTP endpoint called for realm: " + realm);
}
catch
{
Tracing.Error("Malformed realm: " + realm);
return request.CreateErrorResponse(HttpStatusCode.BadRequest, "malformed realm name.");
}
if (string.IsNullOrWhiteSpace(tokenType))
{
tokenType = ConfigurationRepository.Global.DefaultHttpTokenType;
}
Tracing.Verbose("Token type: " + tokenType);
TokenResponse tokenResponse;
var sts = new STS();
if (sts.TryIssueToken(appliesTo, ClaimsPrincipal.Current, tokenType, out tokenResponse))
{
var resp = request.CreateResponse<TokenResponse>(HttpStatusCode.OK, tokenResponse);
return resp;
}
else
{
return request.CreateErrorResponse(HttpStatusCode.BadRequest, "invalid request.");
}
}
public static IDictionary <string, object> ToDictionaryIn(this System.Net.Http.HttpRequestMessage message)
{
Dictionary <string, object> d = new Dictionary <string, object>();
d.Add("xf-request.message.uri", message.RequestUri.ToString());
d.Add("xf-request.message.local-path", message.RequestUri.LocalPath.Trim(new char[] { '/' }).ToLower());
d.Add("xf-request.message.http-method", message.Method.Method.ToUpper());
if (message.Headers.Authorization != null)
{
d.Add("xf-request.message.auth-schema", message.Headers.Authorization.Scheme);
d.Add("xf-request.message.auth-value", message.Headers.Authorization.Parameter);
if (message.Headers.Authorization.Scheme.Equals("basic", StringComparison.OrdinalIgnoreCase))
{
d.Add("xf-request.message.basic-token", message.Headers.Authorization.Parameter);
}
if (message.Headers.Authorization.Scheme.Equals("bearer", StringComparison.OrdinalIgnoreCase))
{
d.Add("xf-request.message.bearer-token", message.Headers.Authorization.Parameter);
}
}
else
{
d.Add("xf-request.message.auth-schema", "none");
d.Add("xf-request.message.auth-value", "none");
}
d.Add("xf-request.message.protocol", message.RequestUri.Scheme.ToLower());
string host = message.RequestUri.Host.ToLower();
d.Add("xf-request.message.host", host.ToLower());
var parts = host.Split(new char[] { '.' });
if (parts.Length > 1)
{
d.Add("xf-request.message.sub-domain", parts[0].ToLower());
}
if (message.Properties.ContainsKey("MS_HttpContext"))
{
var context = ((System.Web.HttpContextWrapper)message.Properties["MS_HttpContext"]);
if (!String.IsNullOrEmpty(context.Request.UserHostAddress))
{
d.Add("xf-request.message.client-ip", context.Request.UserHostAddress);
}
if (!String.IsNullOrWhiteSpace(context.Request.UserAgent))
{
d.Add("xf-request.message.user-agent", context.Request.UserAgent);
}
}
foreach (var item in message.Headers)
{
d.Add(String.Format("xf-request.header.{0}", item.Key.ToLower()), item.Value);
}
foreach (var item in message.Properties)
{
if (item.Key.Equals("{8572540D-3BD9-46DA-B112-A1E6C9086003}", StringComparison.OrdinalIgnoreCase))
{
QueryStringValueProvider provider = item.Value as QueryStringValueProvider;
if (provider != null)
{
foreach (var kvp in provider.GetKeysFromPrefix(""))
{
string key = kvp.Key;
ValueProviderResult vpr = (ValueProviderResult)provider.GetValue(key);
d.Add(String.Format("xf-request.query-string.{0}", key), vpr.AttemptedValue);
}
}
}
}
foreach (KeyValuePair <string, string> kvp in message.GetQueryNameValuePairs())
{
string key = String.Format("xf-request.query-string.{0}", kvp.Key);
d.Add(key, kvp.Value);
}
return(d);
}
public static Dictionary <string, string> GetODataParams(this HttpRequestMessage request)
{
return(request.GetQueryNameValuePairs().Where(kvp => kvp.Key.StartsWith("$")).ToDictionary(kvp => kvp.Key, kvp => kvp.Value));
}