public async Task InvokeAsync(PipelineContext context, PipelineDelegate next)
        {
            if (_queryParameters.Any())
            {
                if (!context.GetFirst(out Uri uri))
                {
                    throw new PipelineDependencyException <Uri>(this);
                }

                var keyValuePairs = NameValueToKeyValuePairs(HttpUtility.ParseQueryString(uri.Query));
                foreach (var queryParameter in _queryParameters)
                {
                    if (context.Get(queryParameter.ContextVariableName, out string contextParameterValue) && !string.IsNullOrEmpty(contextParameterValue))
                    {
                        keyValuePairs.Add(new KeyValuePair <string, string>(queryParameter.ContextVariableName, contextParameterValue));
                    }
                    else
                    if (!queryParameter.Optional)
                    {
                        context.AddNotification(this, $"Context variable '{queryParameter.ContextVariableName}' was not found or does not contain a value and is not optional");
                        return;
                    }
                }

                var          ub = new UriBuilder(uri);
                QueryBuilder qb = new QueryBuilder(keyValuePairs);
                ub.Query = qb.ToString();
                context.AddOrReplace(ub.Uri);

                await next.Invoke();
            }
        }
        public async Task InvokeAsync(PipelineContext context, PipelineDelegate next)
        {
            if (context.GetFirst(out IEnumerable <DublinBikeStation> response))
            {
                if (context.Get("orderBy", out string value))
                {
                    var index = orderIdentifiers
                                .Select((x, i) => new { index = i, identifer = x })
                                .Where(x => string.Compare(x.identifer, value, true) == 0)
                                .Select(x => x.index)
                                .FirstOrDefault();

                    switch (index)
                    {
                    case 1:
                        response = response.OrderBy(x => x.Name);
                        break;

                    case 2:
                        response = response.OrderByDescending(x => x.Available_bikes);
                        break;

                    case 3:
                        response = response.OrderByDescending(x => x.Available_bike_stands);
                        break;

                    case 4:
                        response = response.OrderByDescending(x => x.Last_update);
                        break;

                    default:
                        response = response.OrderBy(x => x.Number);
                        break;
                    }

                    context.AddOrReplace("response", response.Select(x => x));
                }
            }

            await next.Invoke();
        }
Beispiel #3
0
        public async Task InvokeAsync(PipelineContext context, PipelineDelegate next)
        {
            if (!context.GetFirst(out HttpRequestMessage httpRequestMessage) ||
                httpRequestMessage.Method != HttpMethod.Get)
            {
                await next();

                return;
            }

            var ifNoneMatch = httpRequestMessage.Headers.IfNoneMatch;
            var eTag        = ifNoneMatch?.FirstOrDefault();

            await next();

            if (context.GetFirst(out HttpResponseMessage httpResponseMessage) &&
                httpResponseMessage.IsSuccessStatusCode)
            {
                string hash;
                using (var md5 = MD5.Create())
                {
                    var md5Hash = md5.ComputeHash(await httpResponseMessage.Content.ReadAsStreamAsync());
                    hash = Encoding.ASCII.GetString(md5Hash);
                    httpResponseMessage.Headers.TryAddWithoutValidation("Etag", hash);
                }

                if ((eTag != null) && (string.Compare(eTag.Tag, hash) == 0))
                {
                    context
                    .AddOrReplace(new HttpResponseMessage()
                    {
                        StatusCode = System.Net.HttpStatusCode.NotModified
                    })
                    .Add(EtagCacheEnum.NotModified);
                }
            }
        }