/// <summary>
 /// Does the authentication module supports pre-authentication?
 /// </summary>
 /// <param name="client">Client executing this request</param>
 /// <param name="request">Request to authenticate</param>
 /// <param name="credentials">The credentials to be used for the authentication</param>
 /// <returns>true when the authentication module supports pre-authentication</returns>
 public bool CanPreAuthenticate(IRestClient client, IRestRequest request, ICredentials credentials)
 {
     var cred = credentials?.GetCredential(client.BuildUri(request, false), AuthenticationMethod);
     if (cred == null)
         return false;
     return true;
 }
        protected override HttpRequestMessage BuildMessage(IRestRequest request)
        {
            // Create message content
            var content = new MultipartFormDataContent();
            foreach (var param in request.Parameters) {
                var file = param.Value as FileParameter;

                if (file != null) {
                    var contentPart = new ByteArrayContent(file.Content);
                    contentPart.Headers.Add("Content-Type", file.ContentType);
                    content.Add(contentPart, param.Key, file.Name);
                }
                else {
                    var contentPart = new StringContent(param.Value.ToString());
                    content.Add(contentPart, param.Key);
                }
            }

            // Build message
            var message = new HttpRequestMessage(request.Verb.ToHttpMethod(), request.Command) {
                Content = content
            };

            return message;
        }
        /// <summary>
        /// Create the client
        /// </summary>
        /// <param name="client">The REST client that wants to create the HTTP client</param>
        /// <param name="request">The REST request for which the HTTP client is created</param>
        /// <returns>A new HttpClient object</returns>
        /// <remarks>
        /// The DefaultHttpClientFactory contains some helpful protected methods that helps gathering
        /// the data required for a proper configuration of the HttpClient.
        /// </remarks>
        public virtual IHttpClient CreateClient(IRestClient client, IRestRequest request)
        {
            var headers = new GenericHttpHeaders();
            var httpClient = new DefaultHttpClient(this, headers)
            {
                BaseAddress = GetBaseAddress(client)
            };
            if (client.Timeout.HasValue)
            {
                httpClient.Timeout = client.Timeout.Value;
            }

            var proxy = GetProxy(client);
            if (proxy != null)
            {
                httpClient.Proxy = new RequestProxyWrapper(proxy);
            }

            var cookieContainer = GetCookies(client, request);
            if (cookieContainer != null)
            {
                httpClient.CookieContainer = cookieContainer;
            }

            if (_setCredentials)
            {
                var credentials = client.Credentials;
                if (credentials != null)
                {
                    httpClient.Credentials = credentials;
                }
            }

            return httpClient;
        }
        /// <summary>
        /// Merge parameters from client and request
        /// </summary>
        /// <param name="client">The REST client that will execute the request</param>
        /// <param name="request">The REST request</param>
        /// <returns>A list of merged parameters</returns>
        public static IList<Parameter> MergeParameters([CanBeNull] this IRestClient client, IRestRequest request)
        {
            var parameters = new List<Parameter>();

            // Add default parameters first
            if (client != null)
            {
                parameters.AddRange(client.DefaultParameters);
            }

            // Now the client parameters
            if (request != null)
            {
                parameters.AddRange(request.Parameters);
            }

            var comparer = new ParameterComparer(client, request);

            var result = parameters
                .Select((p, i) => new { Parameter = p, Index = i })

                // Group by parameter type/name
                .GroupBy(x => x.Parameter, comparer)

                // Select only the last of all duplicate parameters
                .Select(x => new { x.Last().Parameter, x.First().Index })

                // Sort by appearance
                .OrderBy(x => x.Index)
                .Select(x => x.Parameter)
                .ToList();

            return result;
        }
 protected override bool IsCanProcessRequest(IRestRequest request)
 {
     return (request.Verb == HttpVerb.Post || request.Verb == HttpVerb.Put)
         && request.GetType() == typeof(RestRequest)
         && request.Parameters != null
         && request.Parameters.Any(p => p.Value is FileParameter);
 }
Esempio n. 6
0
        public void ApplyOptions(IRestRequest request, bool isGet)
        {
            if (_options == null)
            {
                return;
            }
            ApplyOptionsStrategy applyOptionsStrategy = isGet
                                                            ? (ApplyOptionsStrategy)
                                                              new GetApplyOptionsStrategy(request, _options)
                                                            : new PostApplyOptionsStrategy(request, _options);
            if (_options.Pretty)
            {
                applyOptionsStrategy.ApplyPretty();
            }

            if (_options.Fields != null && _options.Fields.Count > 0)
            {
                applyOptionsStrategy.ApplyFields();
            }

            if (_options.Expand != null && _options.Expand.Count > 0)
            {
                applyOptionsStrategy.ApplyExpand();
            }
            applyOptionsStrategy.Finish();
        }
 private void PopulateRoutes(IRestRequest request)
 {
     foreach (var route in _definition.Routes)
     {
         request.AddParameter("routes", route.ToString());
     }
 }
 private void PopulateSubEntities(IRestRequest request)
 {
     new LobImageFilePopulator(_definition.Front, "front").Populate(request);
     new LobImageFilePopulator(_definition.Back, "back").Populate(request);
     if (_definition.Data != null) new DataPopulator(_definition.Data).Populate(request);
     if (_definition.MetaData != null) new MetaDataPopulator(_definition.MetaData).Populate(request);
 }
        /// <summary>
        /// Handles the specified request by applying all current filters.
        /// </summary>
        /// <param name="request">The REST API request that will be used to instantiate this state instance.</param>
        /// <returns></returns>
        public IRestResponse Handle(IRestRequest request)
        {
            var redirectable = request as RedirectableRestRequest;
            string originalBaseUrl = null;
            IRestResponse result = null;

            foreach (var filter in filters)
            {
                filter.Handle((IRestClient)this, request);
            }

            // Prevent parallel execution issues (per instance) since this is a destructive property pattern
            lock (_lock)
            {
                if (redirectable != null && redirectable.BaseUrl != this.BaseUrl && !string.IsNullOrEmpty(redirectable.BaseUrl))
                {
                    originalBaseUrl = this.BaseUrl;
                    this.BaseUrl = redirectable.BaseUrl;
                }

                result = this.Execute(request);

                if (originalBaseUrl != null)
                {
                    this.BaseUrl = originalBaseUrl;
                }
            }

            return result;
        }
 private void ReplaceAcceptWithJson(IRestRequest restRequest)
 {
     foreach (var parameter in restRequest.Parameters.Where(p => p.Name == "Accept"))
     {
         parameter.Value = "application/json";
     }
 }
Esempio n. 11
0
        /// <summary>
        /// Override the method which does the actually call against the Tictail API using REST client
        /// These are both 3-party and should be working just fine
        /// </summary>
        /// <param name="request">RestRequst, is not needed for this</param>
        /// <returns>A RestResonse object</returns>
        protected override IRestResponse RestRequest(IRestRequest request)
        {
            IRestResponse response = new RestResponse();
            response.StatusCode = StatusCode;
            response.ResponseStatus = ResponseStatus;
            response.Content = Content;

            if (ResponseHeaders == null)
            {
                return response;
            }

            foreach (var header in ResponseHeaders)
            {
                response.Headers.Add(new Parameter()
                {
                    Name = header.Key,
                    Value = header.Value,
                    Type = ParameterType.HttpHeader
                });

            }

            return response;
        }
Esempio n. 12
0
 public RestException(IRestRequest request, IRestResponse response)
     : base(string.Format("The endpoint at '{0}' didn't respond with 'OK'. Instead it was '{1}'.",
         response.ResponseUri, response.StatusCode), response.ErrorException??new Exception(response.Content))
 {
     Request = request;
     Response = response;
 }
        private BillingConnectorResponse PostApi(string segment, IRestRequest request)
        {
            try
            {
                log.InfoFormat("Invoking billing API on {0} with segment {1}", configuration.Url, segment);

                request.AddHeader("apikey", configuration.ApiKey);

                var response = client.Post(request);

                if (response.StatusCode == HttpStatusCode.OK)
                    return new BillingConnectorResponse(true);

                var failureMessage =
                    string.Format(
                        "Call to billing API return non OK status code. The status code was {0}. The response status code was {1}. The error description is {2}",
                        response.StatusCode, response.ResponseStatus, response.ErrorMessage);

                log.ErrorFormat(failureMessage);
            }
            catch (Exception e)
            {
                log.ErrorFormat("Failed to invoke billing API on {0} because {1}", configuration.Url, e);
            }
            return new BillingConnectorResponse(false);
        }
Esempio n. 14
0
 public BaseRestService(IRestHandler restHandler, IFormat formator, IRestRequest restRequest)
 {
     _restHandler = restHandler;
     _formator = formator;
     _restRequest = restRequest;
     Initialize();
 }
Esempio n. 15
0
        public void Authenticate(IRestClient client, IRestRequest request)
        {
            DateTime signingDate = DateTime.UtcNow;
            SetContentMd5(request);
            SetContentSha256(request);
            SetHostHeader(client, request);
            SetDateHeader(request, signingDate);
            SortedDictionary<string, string> headersToSign = GetHeadersToSign(request);
            string signedHeaders = GetSignedHeaders(headersToSign);
            string region = Regions.GetRegion(client.BaseUrl.Host);
            string canonicalRequest = GetCanonicalRequest(client, request, headersToSign);
            byte[] canonicalRequestBytes = System.Text.Encoding.UTF8.GetBytes(canonicalRequest);
            string canonicalRequestHash = BytesToHex(ComputeSha256(canonicalRequestBytes));
            string stringToSign = GetStringToSign(region, canonicalRequestHash, signingDate);
            byte[] signingKey = GenerateSigningKey(region, signingDate);

            byte[] stringToSignBytes = System.Text.Encoding.UTF8.GetBytes(stringToSign);

            byte[] signatureBytes = SignHmac(signingKey, stringToSignBytes);

            string signature = BytesToHex(signatureBytes);

            string authorization = GetAuthorizationHeader(signedHeaders, signature, signingDate, region);
            request.AddHeader("Authorization", authorization);
        }
        /// <summary>
        /// Gets the basic content (without files) for a request
        /// </summary>
        /// <param name="client">The REST client that will execute the request</param>
        /// <param name="request">REST request to get the content for</param>
        /// <returns>The HTTP content to be sent</returns>
        internal static IHttpContent GetBasicContent([CanBeNull] this IRestClient client, IRestRequest request)
        {
            IHttpContent content;
            var parameters = client.MergeParameters(request);
            var body = parameters.FirstOrDefault(x => x.Type == ParameterType.RequestBody);
            if (body != null)
            {
                content = request.GetBodyContent(body);
            }
            else
            {
                if (client.GetEffectiveHttpMethod(request) == Method.POST)
                {
                    var getOrPostParameters = parameters.GetGetOrPostParameters().ToList();
                    if (getOrPostParameters.Count != 0)
                    {
                        content = new PostParametersContent(getOrPostParameters);
                    }
                    else
                    {
                        content = null;
                    }
                }
                else
                {
                    content = null;
                }
            }

            return content;
        }
        protected override HttpRequestMessage BuildMessage(IRestRequest request)
        {
            var internalRequest = request as PostContentRestRequest;
            if (internalRequest == null)
                throw new ArgumentException($"'{nameof(request)}' is not the PostContentRestRequest.");

            // build url with parameters
            bool fistParam = true;
            var cmdBuilder = new StringBuilder(request.Command);

            if (request.Parameters != null) {
                foreach (var param in request.Parameters) {
                    var divider = fistParam ? "?" : "&";

                    cmdBuilder.Append($"{divider}{param.Key}={param.Value.ToString()}");
                    fistParam = false;
                }
            }

            // Create POST request
            var message = new HttpRequestMessage(request.Verb.ToHttpMethod(), cmdBuilder.ToString()) {
                Content = new StreamContent(internalRequest.Content)
            };

            return message;
        }
        /// <summary>
        /// Gets the content for a request
        /// </summary>
        /// <param name="client">The REST client that will execute the request</param>
        /// <param name="request">REST request to get the content for</param>
        /// <returns>The HTTP content to be sent</returns>
        internal static IHttpContent GetContent([CanBeNull] this IRestClient client, IRestRequest request)
        {
            HttpContent content;
            var parameters = client.MergeParameters(request);
            var collectionMode = request?.ContentCollectionMode ?? ContentCollectionMode.MultiPartForFileParameters;
            if (collectionMode != ContentCollectionMode.BasicContent)
            {
                var fileParameters = parameters.GetFileParameters().ToList();
                if (collectionMode == ContentCollectionMode.MultiPart || fileParameters.Count != 0)
                {
                    content = client.GetMultiPartContent(request);
                }
                else
                {
                    content = client.GetBasicContent(request);
                }
            }
            else
            {
                content = client.GetBasicContent(request);
            }

            if (content == null)
                return null;

            return new DefaultHttpContent(content);
        }
Esempio n. 19
0
 public void Authenticate(IRestClient client, IRestRequest request)
 {
     if(!request.Parameters.Any(p => p.Name.Equals("Authorization", StringComparison.OrdinalIgnoreCase)))
     {
         request.AddParameter("Authorization", "SuTToken " + _token, ParameterType.HttpHeader);
     }
 }
Esempio n. 20
0
		private async Task<IRestResponse> ExecuteInternal(IRestRequest request, string httpMethod, Func<IHttp, string, Task<HttpResponse>> getResponse)
		{
			AuthenticateIfNeeded(this, request);

			// add Accept header based on registered deserializers
			var accepts = string.Join(", ", AcceptTypes.ToArray());
			this.AddDefaultParameter("Accept", accepts, ParameterType.HttpHeader);

			IRestResponse response = new RestResponse();
			try
			{
				var http = HttpFactory.Create();

				ConfigureHttp(request, http);

                //TODO: Add support for Proxy
				//ConfigureProxy(http);

				response = ConvertToRestResponse(request, await getResponse(http, httpMethod));
				response.Request = request;
				response.Request.IncreaseNumAttempts();

			}
			catch (Exception ex)
			{
				response.ResponseStatus = ResponseStatus.Error;
				response.ErrorMessage = ex.Message;
				response.ErrorException = ex;
			}

			return response;
		}
Esempio n. 21
0
 public override void Authenticate(IRestClient client, IRestRequest request)
 {
     if (!string.IsNullOrWhiteSpace(AccessToken))
     {
         request.AddHeader("authorization", string.Format("bearer {0}", AccessToken));
     }
 }
Esempio n. 22
0
 public When(IRestClient client, IRestRequest request, IRestResponse response)
 {
     this.client = client;
     this.request = request;
     this.response = response;
     data = new Object();
 }
Esempio n. 23
0
        public HttpRequestMessage Build(IRestRequest request, IDictionary<string, string> persistentHeaders)
        {
            if (!this.IsCanProcessRequest(request))
                return null;

            HttpRequestMessage message = this.BuildMessage(request);

            // Set headers
            message.Headers.Add("Accept", "application/json");

            // Add persistent headers
            if (request.Headers != null) {
                foreach (var header in request.Headers)
                    this.AddHeader(header.Key, header.Value, message);
            }

            // Add message headers
            if (persistentHeaders != null) {
                foreach (var header in persistentHeaders)
                    if (request.Headers == null || !request.Headers.ContainsKey(header.Key))
                        this.AddHeader(header.Key, header.Value, message);
            }

            return message;
        }
Esempio n. 24
0
 internal void Apply(IRestRequest request)
 {
     _ops.ForEach((op) =>
     {
         request.AddQueryParameter(op.Type.ToString(), op.Value);
     });
 }
        public override void AddFilter(IRestRequest request)
        {
            base.AddFilter(request);

            if (MinimumId != null)
            {
                request.AddParameter("min_id", MinimumId, ParameterType.GetOrPost);
            }
            if (MaximumId != null)
            {
                request.AddParameter("max_id", MaximumId, ParameterType.GetOrPost);
            }
            if (Name != null)
            {
                request.AddParameter("name", Name, ParameterType.GetOrPost);
            }
            if (ParentId != null)
            {
                request.AddParameter("parent_id", ParentId, ParameterType.GetOrPost);
            }
            if (IsVisible != null)
            {
                request.AddParameter("is_visible", IsVisible, ParameterType.GetOrPost);
            }
        }
 /// <summary>
 /// Assembles URL to call based on parameters, method and resource
 /// </summary>
 /// <param name="client">RestClient performing the execution</param>
 /// <param name="request">RestRequest to execute</param>
 /// <returns>Assembled System.Uri</returns>
 /// <remarks>
 /// RestClient's BuildUri purposefully leaves off the parameters from the uri it builds when the request 
 /// is a POST, PUT, or PATCH.  This extension method aims to undo this feature for debugging reasons
 /// </remarks>
 public static Uri BuildDebugUri(this IRestClient client, IRestRequest request)
 {
     var uri = client.BuildUri(request);
     if (request.Method != Method.POST &&
         request.Method != Method.PUT &&
         request.Method != Method.PATCH)
     {
         return uri;
     }
     else
     {
         var queryParameters = from p in request.Parameters
                               where p.Type == ParameterType.GetOrPost
                               select string.Format("{0}={1}", Uri.EscapeDataString(p.Name), Uri.EscapeDataString(p.Value.ToString()));
         if (!queryParameters.Any())
         {
             return uri;
         }
         else
         {
             var path = uri.OriginalString.TrimEnd('/');
             var query = string.Join("&", queryParameters);
             return new Uri(path + "?" + query);
         }
     }
 }
        public void Authenticate(IRestClient client, IRestRequest request)
        {
            if (request.Parameters.Exists(p => p.Name.Equals("Cookie", StringComparison.InvariantCultureIgnoreCase)))
                return;

            request.AddParameter("cookie", _authHeader, ParameterType.HttpHeader);
        }
        private void LogRequest(RestClient restClient, IRestRequest request, IRestResponse response, long durationMs)
        {
            var requestToLog = new
            {
                resource = request.Resource,
                // Parameters are custom anonymous objects in order to have the parameter type as a nice string
                // otherwise it will just show the enum value
                parameters = request.Parameters.Select(parameter => new
                {
                    name = parameter.Name,
                    value = parameter.Value,
                    type = parameter.Type.ToString()
                }),
                // ToString() here to have the method as a nice string otherwise it will just show the enum value
                method = request.Method.ToString(),
                // This will generate the actual Uri used in the request
                uri = restClient.BuildUri(request),
            };

            var responseToLog = new
            {
                statusCode = response.StatusCode,
                content = response.Content,
                headers = response.Headers,
                // The Uri that actually responded (could be different from the requestUri if a redirection occurred)
                responseUri = response.ResponseUri,
                errorMessage = response.ErrorMessage,
            };

            Trace.Write(string.Format("Request completed in {0} ms, Request: {1}, Response: {2}",
                    durationMs,
                    JsonConvert.SerializeObject(requestToLog),
                    JsonConvert.SerializeObject(responseToLog)));
        }
Esempio n. 29
0
 private void ApplyOptions(IRestRequest request, bool isGet)
 {
     if (_asanaOptionsApplier != null)
     {
         _asanaOptionsApplier.ApplyOptions(request, true);
     }
 }
 /// <summary>
 /// Modifies the request to ensure that the authentication requirements are met.
 /// </summary>
 /// <param name="client">Client executing this request</param>
 /// <param name="request">Request to authenticate</param>
 public void Authenticate(IRestClient client, IRestRequest request)
 {
     // only add the Authorization parameter if it hasn't been added by a previous Execute
     if (request.Parameters.Any(p => p.Name != null && p.Name.Equals("Authorization", StringComparison.OrdinalIgnoreCase)))
         return;
     request.AddParameter("Authorization", this._authHeader, ParameterType.HttpHeader);
 }
Esempio n. 31
0
 public virtual Task <IRestResponse> ExecuteTaskAsync(
     IRestRequest request,
     CancellationToken token,
     Method httpMethod
     )
 => ExecuteAsync(request, httpMethod, token);
Esempio n. 32
0
 /// <summary>
 /// Allows for extending response processing for <see cref="ApiClient"/> generated code.
 /// </summary>
 /// <param name="request">The RestSharp request object</param>
 /// <param name="response">The RestSharp response object</param>
 partial void InterceptResponse(IRestRequest request, IRestResponse response);
Esempio n. 33
0
 public QueryRouterService GetSingleObject(string schemaId, string objectId)
 {
     _request = new RestRequest($"/single/{objectId}", Method.POST);
     _request.AddHeader("SCHEMA_ID", schemaId);
     return(this);
 }
Esempio n. 34
0
 public QueryRouterService GetAllObjectsFromSchema(string schemaId)
 {
     _request = new RestRequest("schema", Method.GET);
     _request.AddHeader("SCHEMA_ID", schemaId);
     return(this);
 }
Esempio n. 35
0
 /// <summary>
 ///     Executes the specified request and downloads the response data
 /// </summary>
 /// <param name="request">Request to execute</param>
 /// <returns>Response data</returns>
 // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Global
 public byte[] DownloadData(IRestRequest request) => DownloadData(request, false);
Esempio n. 36
0
 /// <summary>
 /// Execute a manual REST request
 /// </summary>
 /// <param name="request">The RestRequest to execute (will use client credentials)</param>
 public virtual IRestResponse Execute(IRestRequest request)
 {
     return(_client.Execute(request));
 }
Esempio n. 37
0
        private T Execute <T>(IRestRequest request) where T : new()
        {
            var response = Execute <IRestResponse <T> >(request, client => client.Execute <T>);

            return(response.Data);
        }
Esempio n. 38
0
        private IRestResponse Execute(IRestRequest request)
        {
            var response = Execute <IRestResponse>(request, client => client.Execute);

            return(response);
        }
        public AccountResponseCollection List()
        {
            IRestRequest request = this.CreateRequest(this.Resource, Method.GET);

            return(this.ExecuteRequest <AccountResponseCollection>(request).Data);
        }
Esempio n. 40
0
 /// <summary>
 /// Allows for extending request processing for <see cref="ApiClient"/> generated code.
 /// </summary>
 /// <param name="request">The RestSharp request object</param>
 partial void InterceptRequest(IRestRequest request);
Esempio n. 41
0
 static void Configure(string baseUrl, IRestRequest request)
 {
     rClient = new RestClient(baseUrl);
     req     = request;
 }
Esempio n. 42
0
 /// <summary>
 /// Sets 'x-amz-date' http header.
 /// </summary>
 /// <param name="request">Instantiated request object</param>
 /// <param name="signingDate">Date for signature to be signed</param>
 private void SetDateHeader(IRestRequest request, DateTime signingDate)
 {
     request.AddHeader("x-amz-date", signingDate.ToString("yyyyMMddTHHmmssZ"));
 }
Esempio n. 43
0
 static void AddParameters(IRestRequest request)
 {
     request.AddParameter("foo", "bar");
     request.AddParameter("a name with spaces", "somedata");
 }
Esempio n. 44
0
 /// <summary>
 /// Set 'Host' http header.
 /// </summary>
 /// <param name="request">Instantiated request object</param>
 /// <param name="hostUrl">Host url</param>
 private void SetHostHeader(IRestRequest request, string hostUrl)
 {
     request.AddHeader("Host", hostUrl);
 }
 protected void AddAuthorizationHeader(IRestRequest request, string apiKey)
 {
     request?.AddHeader(AuthenticationHeaderName, string.Format(AuthenticationHeaderValueFormat, apiKey));
 }
Esempio n. 46
0
 protected IRestResponse SendRequest(IRestRequest request)
 {
     return(_client.Execute(request));
 }
Esempio n. 47
0
        /// <summary>
        ///     Reconcile ExchangeCommand parameters with supplied and default values, and populate them into the IRestRequest
        /// </summary>
        /// <param name="request">Unpopulated IRestRequest</param>
        /// <param name="command">Reference Command</param>
        /// <param name="pair">Trading Pair</param>
        /// <param name="values">Explicitly supplied parameter values</param>
        private static void PopulateCommandParameters(IRestRequest request, IExchangeCommand command,
                                                      TradingPair pair, IDictionary <StandardParameter, string> values)
        {
            foreach (var param in command.Parameters)
            {
                var parameter = param.Value;

                string value;

                switch (parameter.StandardParameterIdentifier)
                {
                case StandardParameter.Price:
                case StandardParameter.Amount:
                case StandardParameter.Id:
                case StandardParameter.Timestamp:
                case StandardParameter.Limit:
                    value = values[parameter.StandardParameterIdentifier];
                    break;

                case StandardParameter.Base:
                    value = pair.BaseCurrency.ToString();
                    break;

                case StandardParameter.Counter:
                    value = pair.CounterCurrency.ToString();
                    break;

                case StandardParameter.Currency:
                    value = pair.BaseCurrency.ToString();
                    break;

                case StandardParameter.CurrencyFullName:
                    value = pair.BaseCurrency.GetDescription();
                    break;

                case StandardParameter.Pair:
                    value = pair.ToString();
                    break;

                case StandardParameter.UnixTimestamp:
                    value = DateTime.UtcNow.AddHours(-1).ToUnixTime().ToStringInvariant();
                    break;

                case StandardParameter.None:
                    value = parameter.DefaultValue;
                    break;

                default:
                    value = string.Empty;
                    break;
                }

                var parameterType = ParameterType.GetOrPost;

                if (parameter.ParameterMethod == ParameterMethod.Url)
                {
                    parameterType = ParameterType.UrlSegment;
                }
                else if (parameter.ParameterMethod == ParameterMethod.QueryString)
                {
                    parameterType = ParameterType.QueryString;
                }

                request.AddParameter(parameter.ExchangeParameterName, value, parameterType);
            }
        }
Esempio n. 48
0
 public RestRequestAsyncHandle ExecuteAsync <T>(IRestRequest request, Action <IRestResponse <T> > callback) where T : new()
 {
     request.DateFormat = string.IsNullOrEmpty(request.DateFormat) ? DefaultDateParameterFormat : request.DateFormat;
     return(client.ExecuteAsync <T>(request, callback));
 }
Esempio n. 49
0
 IRestResponse <T> IEdsmRestClient.Execute <T>(IRestRequest request) => restClient.Execute <T>(request);
Esempio n. 50
0
 /// <summary>
 /// Clones the current state instance.
 /// </summary>
 /// <param name="request">The REST API request used to create this state instance.</param>
 /// <param name="response">The REST API response used to create this state instance.</param>
 /// <param name="client">The REST API client used to create this state instance.</param>
 /// <returns>A cloned instance of the current state instance.</returns>
 protected abstract GedcomxApplicationState Clone(IRestRequest request, IRestResponse response, IFilterableRestClient client);
 public static Task <IRestResponse> ExecuteAsync(this RestClient client, IRestRequest request)
 {
     return(client.ExecuteAsync(request, r => r));
 }
Esempio n. 52
0
        private void ConfigureHttp(IRestRequest request, IHttp http)
        {
            http.AlwaysMultipartFormData = request.AlwaysMultipartFormData;
            http.UseDefaultCredentials   = request.UseDefaultCredentials;
            http.ResponseWriter          = request.ResponseWriter;

            http.CookieContainer = CookieContainer;

            // move RestClient.DefaultParameters into Request.Parameters
            foreach (var p in DefaultParameters)
            {
                if (request.Parameters.Any(p2 => p2.Name == p.Name && p2.Type == p.Type))
                {
                    continue;
                }

                request.AddParameter(p);
            }

            // Add Accept header based on registered deserializers if none has been set by the caller.
            if (request.Parameters.All(p2 => p2.Name.ToLowerInvariant() != "accept"))
            {
                var accepts = string.Join(", ", AcceptTypes.ToArray());
                request.AddParameter("Accept", accepts, ParameterType.HttpHeader);
            }

            http.Url             = BuildUri(request);
            http.PreAuthenticate = PreAuthenticate;

            var userAgent = UserAgent ?? http.UserAgent;

            http.UserAgent = userAgent.HasValue() ? userAgent : "RestSharp/" + version;

            var timeout = request.Timeout > 0 ? request.Timeout : Timeout;

            if (timeout > 0)
            {
                http.Timeout = timeout;
            }

            var readWriteTimeout = request.ReadWriteTimeout > 0 ? request.ReadWriteTimeout : ReadWriteTimeout;

            if (readWriteTimeout > 0)
            {
                http.ReadWriteTimeout = readWriteTimeout;
            }

#if !SILVERLIGHT
            http.FollowRedirects = FollowRedirects;
#endif
#if FRAMEWORK
            if (ClientCertificates != null)
            {
                http.ClientCertificates = ClientCertificates;
            }

            http.MaxRedirects = MaxRedirects;
#endif

            if (request.Credentials != null)
            {
                http.Credentials = request.Credentials;
            }

            var headers = from p in request.Parameters
                          where p.Type == ParameterType.HttpHeader
                          select new HttpHeader
            {
                Name  = p.Name,
                Value = p.Value.ToString()
            };

            foreach (var header in headers)
            {
                http.Headers.Add(header);
            }

            var cookies = from p in request.Parameters
                          where p.Type == ParameterType.Cookie
                          select new HttpCookie
            {
                Name  = p.Name,
                Value = p.Value.ToString()
            };

            foreach (var cookie in cookies)
            {
                http.Cookies.Add(cookie);
            }

            var @params = from p in request.Parameters
                          where p.Type == ParameterType.GetOrPost &&
                          p.Value != null
                          select new HttpParameter
            {
                Name  = p.Name,
                Value = p.Value.ToString()
            };

            foreach (var parameter in @params)
            {
                http.Parameters.Add(parameter);
            }

            foreach (var file in request.Files)
            {
                http.Files.Add(new HttpFile {
                    Name = file.Name, ContentType = file.ContentType, Writer = file.Writer, FileName = file.FileName, ContentLength = file.ContentLength
                });
            }

            var body = (from p in request.Parameters
                        where p.Type == ParameterType.RequestBody
                        select p).FirstOrDefault();

            if (body != null)
            {
                object val = body.Value;
                if (val is byte[])
                {
                    http.RequestBodyBytes = (byte[])val;
                }
                else
                {
                    http.RequestBody = body.Value.ToString();
                }
                http.RequestContentType = body.Name;
            }
#if FRAMEWORK
            ConfigureProxy(http);
#endif
        }
Esempio n. 53
0
 /// <summary>
 /// Initializes a new instance of the <see cref="RestRequestEventArgs"/> class.
 /// </summary>
 /// <param name="request">The request object.</param>
 public RestRequestEventArgs(IRestRequest request)
 {
     Request = request;
 }
Esempio n. 54
0
 public Uri BuildUri(IRestRequest request) => restClient.BuildUri(request);
 public Task PreAuthenticate(IRestClient client, IRestRequest request, ICredentials credentials)
 {
     return(Authenticate(client, request));
 }
 /// <summary>
 /// Gets the content for a request.
 /// </summary>
 /// <param name="request">The <see cref="IRestRequest"/> to get the content for.</param>
 /// <returns>The <see cref="IHttpContent"/> for the <paramref name="request"/></returns>
 protected override IHttpContent GetContent(IRestRequest request)
 {
     return(RestClientExtensions.GetContent(this, request));
 }
        /// <summary>
        /// Deletes an order with the given Id.
        /// </summary>
        /// <param name="orderId">The order object's Id.</param>
        public async Task DeleteAsync(long orderId)
        {
            IRestRequest req = RequestEngine.CreateRequest("orders/{0}.json".FormatWith(orderId), Method.DELETE);

            await RequestEngine.ExecuteRequestAsync(_RestClient, req);
        }
Esempio n. 58
0
 public OrientCommandException(IRestRequest request, IRestResponse response, T input) : base(GetMessage(input), GetInnerException(request, response))
 {
     Request  = request;
     Response = response;
     Input    = input;
 }
        /// <summary>
        /// Opens a closed order.
        /// </summary>
        /// <param name="id">The order's id.</param>
        public async Task OpenAsync(long id)
        {
            IRestRequest req = RequestEngine.CreateRequest("orders/{0}/open.json".FormatWith(id), Method.POST);

            await RequestEngine.ExecuteRequestAsync(_RestClient, req);
        }
 public bool CanPreAuthenticate(IRestClient client, IRestRequest request, ICredentials credentials)
 {
     return(true);
 }