public Task OnRequestExecutionAsync(RequestExecutingContext context, RequestExecutionDelegate next)
            {
                var request = context.GoContext.Request;

                const string key = "access_token";

                if (!request.Query.TryGetValue(key, out var values) || values == StringValues.Empty)
                {
                    request.AddQuery(key, _options.DefaultAccessToken);
                }

                return(next());
            }
            public Task OnRequestExecutionAsync(RequestExecutingContext context, RequestExecutionDelegate next)
            {
                var request = context.GoContext.Request;

                const string key = "Authorization";

                if (!request.Headers.TryGetValue(key, out var values) || values == StringValues.Empty)
                {
                    request.AddHeader(key, "Basic " + _options.AccessToken);
                }

                return(next());
            }
Esempio n. 3
0
        private RequestExecutionDelegate GetRequestExecutionDelegate(object[] arguments)
        {
            var requestExecutingContext = new RequestExecutingContext(RequestContext, Interceptors, MappingArguments(arguments));
            var requestExecutedContext  = new RequestExecutedContext(RequestContext, Interceptors);

            var requestInterceptors = Interceptors
                                      .OfType <IAsyncRequestInterceptor>()
                                      .ToArray();
            IList <Func <RequestExecutionDelegate, RequestExecutionDelegate> > requestExecutions = new List <Func <RequestExecutionDelegate, RequestExecutionDelegate> >();

            foreach (var interceptor in requestInterceptors)
            {
                requestExecutions.Add(next =>
                {
                    return(async() =>
                    {
                        await interceptor.OnRequestExecutionAsync(requestExecutingContext, next);
                        if (requestExecutingContext.Result != null)
                        {
                            requestExecutedContext.Result = requestExecutingContext.Result;
                        }
                        return requestExecutedContext;
                    });
                });
            }

            RequestExecutionDelegate requestInvoker = async() =>
            {
                try
                {
                    requestExecutedContext.Result = await DoInvokeAsync();
                }
                catch (Exception e)
                {
                    requestExecutedContext.ExceptionDispatchInfo = ExceptionDispatchInfo.Capture(e);
                }

                return(requestExecutedContext);
            };

            foreach (var func in requestExecutions.Reverse())
            {
                requestInvoker = func(requestInvoker);
            }

            return(requestInvoker);
        }
        public virtual async Task OnRequestExecutionAsync(RequestExecutingContext context, RequestExecutionDelegate next)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }
            if (next == null)
            {
                throw new ArgumentNullException(nameof(next));
            }

            OnRequestExecuting(context);

            if (context.Result == null)
            {
                OnRequestExecuted(await next());
            }
        }
Esempio n. 5
0
 public Task OnRequestExecutionAsync(RequestExecutingContext context, RequestExecutionDelegate next)
 {
     return(_execution != null?_execution(context, next) : next());
 }