/// <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());
}
