/// <summary> /// This method is used to get a commit author's full name via the github rest api. /// Reference: https://docs.github.com/en/rest /// For an example response: https://api.github.com/repos/Azure/iotedge/commits/704250b /// </summary> /// <param name="commit">Commit for which to get the author's full name.</param> /// <returns>Full name of author.</returns> public async Task <string> GetAuthorFullNameFromCommitAsync(string commit) { string requestPath = string.Format(UserPathSegmentFormat, commit); IFlurlRequest workItemQueryRequest = ((Url)requestPath) .WithHeader("Content-Type", "application/json") .WithHeader("User-Agent", "Azure/iotedge"); JObject result; try { IFlurlResponse response = await workItemQueryRequest.GetAsync(); result = await response.GetJsonAsync <JObject>(); string fullName = result["commit"]["author"]["name"].ToString(); return(fullName); } catch (FlurlHttpException e) { string message = $"Failed making call to commit api: {e.Message}"; Console.WriteLine(message); Console.WriteLine(e.Call.RequestBody); Console.WriteLine(e.Call.Response.StatusCode); Console.WriteLine(e.Call.Response.ResponseMessage); throw new Exception(message); } }
/// <summary> /// Creates a new refund transaction, given the parent transaction id /// </summary> /// <returns> /// Returns <c>Response</c> object. /// </returns> /// <example> /// <code> /// var merchant = new Vpos(); /// var location = merchant.NewRefund("900111222", "123.45"); /// </code> /// </example> /// <param name="parentTransactionId"><c>parentTransactionId</c> This is a string value of the transaction id you're requesting to be refunded.</param> /// <param name="supervisorCard"><c>supervisorCard</c> A 16 characters string digits representing the supervisor card provided by EMIS it defaults to GPO_SUPERVISOR_CARD environment var</param> /// <param name="callbackUrl"><c>callbackUrl</c> the callback url it defaults to 'PAYMENT_CALLBACK_URL' environment var</param> public Response NewRefund(string parentTransactionId, string supervisorCard = null, string callbackUrl = null) { IFlurlResponse result = HttpRequest("transactions") .PostJsonAsync(new { type = "refund", parent_transaction_id = parentTransactionId, supervisor_card = supervisorCard ?? this.gpoSupervisorCard, callback_url = callbackUrl ?? this.refundCallbackUrl }).Result; int status = result.StatusCode; string message = StatusMessage.GetMessage(status); if (status == 202) { var locationResponse = new Response(status, message, Utils.GetLocation(result)); return(locationResponse); } else { var errorResponse = new Response(status, message, details: Utils.GetDetails(result)); return(errorResponse); } }
/// <summary> /// Captures the low-level <seealso cref="HttpResponseMessage" /> from a /// underlying request. Useful in advanced scenarios where you /// want to check HTTP headers, HTTP status code or /// inspect the response body manually. /// </summary> /// <param name="responseGetter">A function that must be called to /// retrieve the <seealso cref="HttpResponseMessage"/> /// </param> /// <returns>Returns the <seealso cref="HttpResponseMessage"/> of the /// underlying HTTP request.</returns> public CoinbaseClient HoistResponse(out Func <IFlurlResponse> responseGetter) { IFlurlResponse msg = null; void CaptureResponse(FlurlCall http) { msg = http.Response; this.Configure(cf => { // Remove Action<HttpCall> from Invocation list // to avoid memory leak from further calls to the same // client object. cf.AfterCall -= CaptureResponse; }); } this.Configure(cf => { cf.AfterCall += CaptureResponse; }); responseGetter = () => msg; return(this); }
/// <summary> /// This method is used to execute a Dev Ops work item query and get the number of bugs for a given query. /// If result is not found for a query, it will return 0. /// Reference: https://docs.microsoft.com/en-us/rest/api/azure/devops/wit/wiql/query%20by%20wiql?view=azure-devops-rest-5.1 /// </summary> /// <param name="bugQuery">Bug query object representing vsts shared queries</param> /// <returns>Number of bugs output by query</returns> public async Task <int> GetBugsCountAsync(BugQuery bugQuery) { // TODO: need to think about how to handle unexpected exception during REST API call string requestPath = string.Format(WorkItemPathSegmentFormat, DevOpsAccessSetting.BaseUrl, this.accessSetting.Organization, this.accessSetting.Project, this.accessSetting.Team); IFlurlRequest workItemQueryRequest = ((Url)requestPath) .WithBasicAuth(string.Empty, this.accessSetting.PersonalAccessToken) .SetQueryParam("api-version", "5.1"); JObject result; try { IFlurlResponse response = await workItemQueryRequest .PostJsonAsync(new { query = bugQuery.GetWiqlFromConfiguration() }); result = await response.GetJsonAsync <JObject>(); } catch (FlurlHttpException e) { Console.WriteLine($"Failed making call to vsts work item api: {e.Message}"); Console.WriteLine(e.Call.RequestBody); Console.WriteLine(e.Call.Response.StatusCode); Console.WriteLine(e.Call.Response.ResponseMessage); return(0); } if (!result.ContainsKey("queryType")) { return(0); } return(result["workItems"].Count()); }
/// <summary> /// Creates a new payment. /// Given a customer cellphone and the amount return a new payment. /// </summary> /// <returns> /// Returns <c>LocationResponse</c> object. /// </returns> /// <example> /// <code> /// var merchant = new Vpos(); /// var location = merchant.NewPayment("900111222", "123.45"); /// </code> /// </example> /// <param name="customer"><c>customer</c> The customer mobile number</param> /// <param name="amount"><c>amount</c> The amount of money being charged</param> /// <param name="postID"><c>postID</c> the point of sale identification it defaults to the 'GPO_POS_ID' environment var</param> /// <param name="callbackUrl"><c>callbackUrl</c> the callback url it defaults to 'PAYMENT_CALLBACK_URL' environment var</param> public Response NewPayment(string customer, string amount, string postID = null, string callbackUrl = null) { IFlurlResponse result = HttpRequest("transactions") .PostJsonAsync(new { type = "payment", mobile = customer, amount, pos_id = postID ?? this.gpoPosID, callback_url = callbackUrl ?? this.paymentCallbackUrl }).Result; int status = result.StatusCode; string message = StatusMessage.GetMessage(status); if (status == 202) { var locationResponse = new Response(status, message, Utils.GetLocation(result)); return(locationResponse); } else { var errorResponse = new Response(status, message, details: Utils.GetDetails(result)); return(errorResponse); } }
/// <inheritdoc/> public override async Task UploadFileAsync(string filename, byte[] fileContent, CloudStorageCredentials credentials) { credentials.ThrowIfInvalid(CredentialsRequirements); try { await InitializeAppRootFolderAsync(credentials.Token.AccessToken); string url = string.Format(UploadUrl, Url.Encode(filename)); byte[] requestBytes = Encoding.UTF8.GetBytes("{ \"item\": { \"@microsoft.graph.conflictBehavior\": \"replace\" } }"); HttpContent sessionContent = new ByteArrayContent(requestBytes); // Using an upload session is the recommended approach for reliable file transfer, // not only for big files. string jsonResponse = await Flurl.Request(url) .WithOAuthBearerToken(credentials.Token.AccessToken) .WithHeader("Content-Type", "application/json") .PostAsync(sessionContent) .ReceiveString(); JsonUploadSession session = JsonConvert.DeserializeObject <JsonUploadSession>(jsonResponse); // Now that we have got the session, the file can be uploaded HttpContent content = new ByteArrayContent(fileContent); IFlurlResponse uploadResponse = await Flurl.Request(session.UploadUrl) .WithHeader("Content-Length", fileContent.Length) .WithHeader("Content-Range", string.Format("bytes 0-{0}/{1}", fileContent.Length - 1, fileContent.Length)) .PutAsync(content); } catch (Exception ex) { throw ConvertToCloudStorageException(ex); } }
private async Task <T> HandleSynologyResponse <T>(IFlurlResponse httpResponse, IApiInfo apiInfo, string apiMethod) { switch (httpResponse.StatusCode) { case (int)HttpStatusCode.OK: var response = await httpResponse.GetJsonAsync <ApiResponse <T> >(); if (!response.Success) { var errorDescription = GetErrorMessage(response?.Error?.Code ?? 0, apiInfo.Name); throw new SynologyApiException(apiInfo, apiMethod, response.Error.Code, errorDescription); } if (typeof(T) == typeof(BaseApiResponse)) { return((T)Activator.CreateInstance(typeof(T), new object[] { response.Success })); } return(response.Data); default: throw new UnexpectedResponseStatusException((HttpStatusCode)httpResponse.StatusCode);; } }
private async Task <TResult> ReadResponseContentAsync <TResult>(IFlurlResponse responseMessage, Func <string, TResult> contentHandler = null) { string content = await responseMessage.GetJsonAsync().ConfigureAwait(false); return(contentHandler != null ? contentHandler(content) : JsonConvert.DeserializeObject <TResult>(content)); }
public static bool IsSuccessful(this IFlurlResponse response) { return (response.StatusCode == (int)HttpStatusCode.OK || response.StatusCode == (int)HttpStatusCode.Created || response.StatusCode == (int)HttpStatusCode.Accepted || response.StatusCode == (int)HttpStatusCode.NoContent); }
private async Task <HttpClientResponse <TEntity> > FormatResponse <TEntity>(IFlurlResponse response) { return(new HttpClientResponse <TEntity> { Data = JsonConvert.DeserializeObject <TEntity>(await response.ResponseMessage.Content.ReadAsStringAsync()), IsSuccessful = response.ResponseMessage.IsSuccessStatusCode, StatusCode = response.ResponseMessage.StatusCode }); }
private async Task HandleErrorsAsync(IFlurlResponse response) { if (response.StatusCode >= 300) { var errorResponse = await ReadResponseContentAsync <ErrorResponse>(response).ConfigureAwait(false); string errorMessage = string.Join(Environment.NewLine, errorResponse.Errors.Select(x => x.Message)); throw new InvalidOperationException($"Http request failed ({(int) response.StatusCode} - {response.StatusCode}):\n{errorMessage}"); } }
public async Task <RealtyObjectsResponse[]> GetRealtyObjects() { FlurlHttp.Configure(setting => { setting.Timeout = new TimeSpan(1, 30, 0); }); IFlurlResponse request = await RequestUrl.PostJsonAsync(_requestObject); DataModel.Response response = await request.GetJsonAsync <DataModel.Response>(); return(response.Result.RealtyObjectsReponses); }
public async Task <Result> CreateDNSRecordAsync(string domainName, DigitalOceanCreateDomainRecordRequest request, string token, CancellationToken cancellation) { string path = string.Format(_createDNSRecordFormat, domainName); IFlurlRequest httpRequest = BuildRequest(token, path); IFlurlResponse response = await httpRequest.PostJsonAsync(request, cancellation); if (response.ResponseMessage.IsSuccessStatusCode) { return(Result.Ok().WithSuccess(string.Format(_createDNSRecordSuccessMessageTemplate, domainName, request.Name))); } return(Result.Fail(string.Format(_createDNSRecordFailureMessageTemplate, domainName, request.Name))); }
private async Task <ApiOffersResponse> PostOffersAsync(ApiOffers offers) { IFlurlResponse httpResponse = await Policy .Handle <HttpRequestException>() .Or <FlurlHttpException>() .OrResult <IFlurlResponse>(result => !result.ResponseMessage.IsSuccessStatusCode) .WaitAndRetryAsync(new TimeSpan[] { TimeSpan.FromSeconds(1) }) .ExecuteAsync(async() => await _basicModel.BasicApiOffers.PostJsonAsync(offers)); ApiOffersResponse apiOffersResponse = await httpResponse.GetJsonAsync <ApiOffersResponse>(); return(apiOffersResponse); }
public async Task <Result> CreateDNSRecordsAsync(GoDaddyCreateDNSRecordsRequest request, CancellationToken cancellation) { string path = string.Format(_createDNSRecordFormat, request.DomainName); IFlurlRequest httpRequest = BuildRequest(request.ApiKey, request.ApiSecret, path); IFlurlResponse response = await httpRequest.PatchJsonAsync(request.Records, cancellation); HttpResponseMessage message = response.ResponseMessage; if (message.StatusCode == HttpStatusCode.OK) { return(Result.Ok().WithSuccess(string.Format(_createDNSRecordSuccessMessageTemplate, request.Records.Count(), request.DomainName))); } return(Result.Fail(string.Format(_createDNSRecordFailureMessageTemplate, request.DomainName))); }
/// <inheritdoc /> public async Task <ICouchDatabase <TSource> > GetOrCreateDatabaseAsync <TSource>(string database, int?shards = null, int?replicas = null, string?discriminator = null, CancellationToken cancellationToken = default) where TSource : CouchDocument { QueryContext queryContext = NewQueryContext(database); IFlurlResponse response = await CreateDatabaseAsync(queryContext, shards, replicas, cancellationToken) .ConfigureAwait(false); if (response.IsSuccessful() || response.StatusCode == (int)HttpStatusCode.PreconditionFailed) { return(new CouchDatabase <TSource>(_flurlClient, _options, queryContext, discriminator)); } throw new CouchException($"Something wrong happened while creating database {database}."); }
public async Task <Result> UpdateDNSRecordAsync(GoDaddyUpdateDNSRecordsRequest request, CancellationToken cancellation) { string path = string.Format(_updateDNSRecordsFormat, request.DomainName, request.RecordType.Value, request.RecordName); IFlurlRequest httpRequest = BuildRequest(request.ApiKey, request.ApiSecret, path); IFlurlResponse response = await httpRequest.PutJsonAsync(new [] { request.Record }, cancellation); HttpResponseMessage message = response.ResponseMessage; if (message.StatusCode == HttpStatusCode.OK) { string resultMessage = string.Format(_updateDNSRecordsSuccessMessageTemplate, request.DomainName, request.RecordName); return(Result.Ok().WithSuccess(resultMessage)); } return(Result.Fail(string.Format(_updateDNSRecordsFailureMessageTemplate, request.RecordName, request.DomainName))); }
internal static async Task <string> GetBadRequestErrorDescriptionAsync(this IFlurlResponse response) { try { var json = await response .GetJsonAsync <JObject>() .ConfigureAwait(false); return(json?.SelectToken("$..ErrorDescription")?.ToString() ?? json.ToString()); } catch { return(null); } }
public async Task <ActionResult <ContactInfoResponse> > Post(ContactInfoRequest requestObject) { IFlurlResponse response = await $"{URLConstants.ContactAPIURL}/api/contacts".PostJsonAsync(requestObject); if (response.StatusCode >= 500) { return(StatusCode(500)); } else if (response.StatusCode >= 400) { return(StatusCode(400)); } ContactInfoResponse responseObject = await response.GetJsonAsync <ContactInfoResponse>(); return(CreatedAtAction("Post", responseObject)); }
public async Task <Result <DigitalOceanGetDomainRecordsResponse> > GetDNSRecordsAsync(DigitalOceanDomain domain, string token, CancellationToken cancellation) { string path = string.Format(_getDNSRecordsFormat, domain.Name); IFlurlRequest httpRequest = BuildRequest(token, path); IFlurlResponse response = await httpRequest.GetAsync(cancellation); HttpResponseMessage message = response.ResponseMessage; if (message.IsSuccessStatusCode) { string content = await message.Content.ReadAsStringAsync(); DigitalOceanGetDomainRecordsResponse records = JsonConvert.DeserializeObject <DigitalOceanGetDomainRecordsResponse>(content); return(Result.Ok(records).WithSuccess(string.Format(_getDNSRecordsSuccessMessageTemplate, records.DomainRecords.Count(), domain.Name))); } return(Result.Fail(string.Format(_getDNSRecordsFailureMessageTemplate, domain.Name))); }
public async Task <ActionResult <ICollection <ContactInfoResponse> > > GetAll() { IFlurlResponse response = await $"{URLConstants.ContactAPIURL}/api/contacts".GetAsync(); if (response.StatusCode >= 500) { return(StatusCode(500)); } else if (response.StatusCode >= 400) { return(StatusCode(400)); } ICollection <ContactInfoResponse> responseObjects = await response.GetJsonAsync <ICollection <ContactInfoResponse> >(); return(Ok(responseObjects)); }
public static async Task <string> GetResponseAsync(string url) { try { IFlurlResponse response = await url.GetAsync(); return(await response.ResponseMessage.Content.ReadAsStringAsync()); } catch (FlurlHttpTimeoutException) { throw new Exception("Response Time Out"); } catch (FlurlHttpException ex) { throw new Exception(ex.Message); } }
public async Task <Result <GoDaddyGetDNSRecordsResponse> > GetDNSRecordsAsync(GoDaddyGetDNSRecordsRequest request, CancellationToken cancellation) { string path = string.Format(_getDNSRecordsFormat, request.DomainName, request.DNSRecordType.Value); IFlurlRequest httpRequest = BuildRequest(request.ApiKey, request.ApiSecret, path); IFlurlResponse response = await httpRequest.GetAsync(cancellation); HttpResponseMessage message = response.ResponseMessage; if (message.StatusCode == HttpStatusCode.OK) { string content = await message.Content.ReadAsStringAsync(); IEnumerable <GoDaddyGetDNSRecordResponse> records = JsonConvert.DeserializeObject <List <GoDaddyGetDNSRecordResponse> >(content); string resultMessage = string.Format(_getDNSRecordsSuccessMessageTemplate, records.Count(), request.DomainName); return(Result.Ok(new GoDaddyGetDNSRecordsResponse(records)).WithSuccess(resultMessage)); } return(Result.Fail(string.Format(_getDNSRecordsFailureMessageTemplate, request.DomainName))); }
private async Task <T> SelectAsync <T>(RealtyObjectsResponse data) { IFlurlResponse responseHttp = await $"{_odata}?$select=mtr_propertyid,statuscode&$filter=mtr_propertyid eq '{data.RealtyObjectId}'".WithOAuthBearerToken(token.Content).GetAsync(); string responseBody = await responseHttp.GetStringAsync(); if (!responseHttp.ResponseMessage.IsSuccessStatusCode && responseHttp.StatusCode != 401) { _logger.Error($"Bad select in the database, Message: {responseBody}, StatusCode: {responseHttp.StatusCode}, Json for request: {JsonConvert.SerializeObject(data)}"); } else if (!responseHttp.ResponseMessage.IsSuccessStatusCode && responseHttp.StatusCode == 401) { await AuthorizeStart(); return(await SelectAsync <T>(data)); } return(JsonConvert.DeserializeObject <T>(responseBody)); }
private async Task <IFlurlResponse> UpdateAsync(PropertyUpdate data) { IFlurlResponse responseHttp = await $"{_odata}({data.PropertyId})".WithOAuthBearerToken(token.Content).PatchJsonAsync(data); string responseBody = await responseHttp.GetStringAsync(); if (!responseHttp.ResponseMessage.IsSuccessStatusCode && responseHttp.StatusCode != 401) { _logger.Error($"Bad update in the database, Message: {responseBody}, StatusCode: {responseHttp.StatusCode}, Json for request: {JsonConvert.SerializeObject(data)}"); } else if (!responseHttp.ResponseMessage.IsSuccessStatusCode && responseHttp.StatusCode == 401) { await AuthorizeStart(); return(await UpdateAsync(data)); } return(responseHttp); }
public async Task <ActionResult> Put(long id, ContactInfoRequest requestObject) { IFlurlResponse response = await $"{URLConstants.ContactAPIURL}/api/contacts/{id}".PutJsonAsync(requestObject); if (response.StatusCode == 404) { return(NotFound()); } else if (response.StatusCode >= 500) { return(StatusCode(500)); } else if (response.StatusCode >= 400) { return(StatusCode(400)); } return(StatusCode(204)); }
/// <summary> /// Get all transactions /// </summary> /// <returns> /// Returns <c>TransactionsResponse</c> object. /// </returns> /// <example> /// <code> /// var merchant = new Vpos(); /// var transactionsResponse = merchant.GetTransactions(); /// </code> /// </example> public Response <List <Transaction> > GetTransactions() { IFlurlResponse result = HttpRequest("transactions") .GetAsync().Result; int status = result.StatusCode; string message = StatusMessage.GetMessage(status); if (status == 200) { var transactions = Utils.GetTransactions(result); var TransactionsResponse = new Response <List <Transaction> >(status, message, transactions); return(TransactionsResponse); } { var errorResponse = new Response <List <Transaction> >(status, message, details: Utils.GetDetails(result)); return(errorResponse); } }
/// <summary> /// Gets a single transaction. /// Given the transaction id or and error object if the transaction was not found. /// </summary> /// <returns> /// Returns <c>Response</c> object. /// </returns> /// <example> /// <code> /// var merchant = new Vpos(); /// var transaction = merchant.GetTransaction("XCSd3csdbadshg67348tgyfr"); /// </code> /// </example> /// <param name="transactionId"><c>transactionId</c> The id of the transaction to retrieve</param> public Response <Transaction> GetTransaction(string transactionId) { IFlurlResponse result = HttpRequest($"transactions/{transactionId}") .GetAsync().Result; int status = result.StatusCode; string message = StatusMessage.GetMessage(status); if (status == 200) { var transaction = result.GetJsonAsync <Transaction>().Result; Response <Transaction> transactionResponse = new Response <Transaction>(status, message, transaction); return(transactionResponse); } { var errorResponse = new Response <Transaction>(status, message, details: Utils.GetDetails(result)); return(errorResponse); } }
private async Task UpdateExistingFile(string fileId, byte[] fileContent, CloudStorageCredentials credentials) { // The resumable upload type is the recommended approach for reliable file transfer, // not only for big files. // Adding SetQueryParam("addParents", DataFolder) is not necessary because the id is unique IFlurlResponse sessionResponse = await Flurl.Request(UploadUrl, fileId) .SetQueryParam("uploadType", "resumable") .WithOAuthBearerToken(credentials.Token.AccessToken) .WithHeader("X-Upload-Content-Type", "application/octet-stream") .WithHeader("X-Upload-Content-Length", fileContent.Length) .PatchAsync(null); string sessionUri = sessionResponse.Headers.FirstOrDefault("Location"); // Now that we have got the session, the file can be uploaded HttpContent content = new ByteArrayContent(fileContent); IFlurlResponse uploadResponse = await Flurl.Request(sessionUri) .WithOAuthBearerToken(credentials.Token.AccessToken) .PutAsync(content); }
private static async Task <string> PostToWindowsUpdateAsync(string method, string message, bool secured) { string _endpoint = Constants.Endpoint; if (secured) { _endpoint += "/secured"; } IFlurlRequest request = _endpoint.WithHeader("MS-CV", MSCV) .WithHeader("SOAPAction", Constants.Action + method) .WithHeader("User-agent", Constants.UserAgent) .WithHeader("Method", "POST"); MSCV = correlationVector.Increment(); StringContent content = new StringContent(message, System.Text.Encoding.UTF8, "application/soap+xml"); IFlurlResponse response = await request.WithClient(flurlClient).SendAsync(HttpMethod.Post, content); return(await response.ResponseMessage.Content.ReadAsStringAsync()); }