private static async Task <HttpResponseMessage> SendSimpleAsync(IFlurlRequest flurlRequest, WebRequestContext requestContext)
{
HttpResponseMessage result = default;
try
{
requestContext.AttemptCnt++;
if (requestContext.MethodType == WebMethodType.GET)
{
result = await flurlRequest.GetAsync();
}
else if (requestContext.MethodType == WebMethodType.POST)
{
result = await flurlRequest.PostJsonAsync((string)requestContext);
}
}
catch (FlurlHttpException flurlException)
{
if (flurlException.Call.Response != null &&
requestContext.AttemptCnt < WebConfig.ReTryCount)
{
result = await SendSimpleAsync(flurlRequest, requestContext);
}
}
catch (Exception)
{
}
return(result);
}
/// <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());
}
/// <inheritdoc />
public async Task <TSource> AddAsync(TSource document, bool batch = false, CancellationToken cancellationToken = default)
{
Check.NotNull(document, nameof(document));
if (!string.IsNullOrEmpty(document.Id))
{
return(await AddOrUpdateAsync(document, batch, cancellationToken)
.ConfigureAwait(false));
}
IFlurlRequest request = NewRequest();
if (batch)
{
request = request.SetQueryParam("batch", "ok");
}
DocumentSaveResponse response = await request
.PostJsonAsync(document, cancellationToken)
.ReceiveJson <DocumentSaveResponse>()
.SendRequestAsync()
.ConfigureAwait(false);
document.ProcessSaveResponse(response);
await UpdateAttachments(document, cancellationToken)
.ConfigureAwait(false);
return(document);
}
public static async Task <dynamic> PostRequest(string[] PathSegments, object RequestBodyObject)
{
IFlurlRequest request = TrackIt_2019.API.BaseUri.AppendPathSegments(PathSegments).WithOAuthBearerToken((string)TrackIt_2019.API.Authentication.Token.access_token);
dynamic result = await request.PostJsonAsync(RequestBodyObject).ReceiveJson();
return(result);
}
/// <summary>
/// Creates a new document and returns it.
/// </summary>
/// <param name="document">The document to create.</param>
/// <param name="batch">Stores document in batch mode.</param>
/// <returns>A task that represents the asynchronous operation. The task result contains the element created.</returns>
public async Task <TSource> CreateAsync(TSource document, bool batch = false)
{
if (!string.IsNullOrEmpty(document.Id))
{
return(await CreateOrUpdateAsync(document)
.ConfigureAwait(false));
}
IFlurlRequest request = NewRequest();
if (batch)
{
request = request.SetQueryParam("batch", "ok");
}
DocumentSaveResponse response = await request
.PostJsonAsync(document)
.ReceiveJson <DocumentSaveResponse>()
.SendRequestAsync()
.ConfigureAwait(false);
document.ProcessSaveResponse(response);
await UpdateAttachments(document)
.ConfigureAwait(false);
return(document);
}
private async Task <HttpResponseMessage> SendAuthorizedHttpPostRequestAsync <TEvent>(IEnumerable <TEvent> events) where TEvent : class
{
IFlurlRequest authorizedRequest =
TopicEndpoint.WithHeader(name: "aeg-sas-key", value: _authenticationKey);
return(await authorizedRequest.PostJsonAsync(events));
}
public static async Task Main(string[] args)
{
#if TESTING
NativeMethods.AllocConsole();
#endif
Log.Info("Begin Program");
// _log.Info("Load Config");
_config = await Config.LoadAsync();
#if TESTING
IFlurlRequest imgUrl = _config.CameraIp.AppendPathSegments($"api/{_config.ApiVersion}", "snapshot20")
.WithHeaders(new { Content_Type = "application/json" });
#else
IFlurlRequest imgUrl = _config.CameraIp.AppendPathSegments($"api/{_config.ApiVersion}", "snapshot")
.WithHeaders(new { Content_Type = "application/json" });
#endif
try {
Log.Info("Obtain Image");
Stream stream = await imgUrl.PostJsonAsync(new { username = _config.User, password = _config.Password })
.ReceiveStream();
Image img = Image.FromStream(stream);
double imgSz = stream.Length.ToKilobyte();
const string image = "image.jpg";
#if TESTING
#endif
img.Save(image, ImageFormat.Jpeg);
Log.Info($"Image Ok! {imgSz} KB");
#if TESTING
_log.Info("Skip FTP Upload");
#else
using var client = new WebClient
{ Credentials = new NetworkCredential(_config.WeatherUndergroundId, _config.WeatherUndergroundKey) };
string uploadUri = _config.WeatherUndergroundFtpUri.AppendPathSegment(image);
Log.Info("Upload to FTP");
client.UploadFile(new Uri(uploadUri), WebRequestMethods.Ftp.UploadFile, image);
Log.Info("Upload Ok!");
#endif
}
catch (FlurlHttpException fhe) {
Log.Error($"Image not ok! {fhe.Message}");
}
catch (IOException ioe) {
Log.Error($"Upload not ok! {ioe.Message}");
}
catch (Exception ex) {
Log.Error("Image or Upload Not Ok!", ex);
}
#if TESTING
Console.WriteLine("Press any key to exit...");
Console.ReadKey(false);
NativeMethods.FreeConsole();
#endif
}
/// <summary>
/// POST request to the API
/// </summary>
/// <typeparam name="T">Type of return data</typeparam>
/// <param name="dtoForCreation">Data Transfer Object for creating new entity</param>
/// <param name="ReturnData"></param>
/// <param name="pathToAppend">Additional path to append on base url (e.g. "lock" custom operation as "/users/1/lock")</param>
public async Task <APIServiceResult <T> > Post <T>(object dtoForCreation, bool ReturnData = false, string pathToAppend = "")
{
try
{
if (!string.IsNullOrWhiteSpace(pathToAppend))
{
request.Url.AppendPathSegment(pathToAppend);
}
var response = await request.PostJsonAsync(dtoForCreation);
RevertToBaseRequest();
if (response.StatusCode != HttpStatusCode.OK)
{
if (response.StatusCode == HttpStatusCode.Forbidden)
{
dlgError.ShowDialog(Resources.AccessDenied);
}
else if (response.StatusCode == HttpStatusCode.BadRequest)
{
if (response.Content != null)
{
dlgError.ShowDialog(await response.Content?.ReadAsStringAsync() ?? string.Empty);
}
}
else if ((int)response.StatusCode == 422)
{
var msg = Resources.InvalidInputData;
if (response.Content != null)
{
msg = await response.Content.ReadAsStringAsync();
}
dlgError.ShowDialog(msg);
}
return(APIServiceResult <T> .WithStatusCode(response.StatusCode));
}
if (ReturnData)
{
var result = await response.Content.ReadAsAsync <T>();
return(APIServiceResult <T> .OK(result));
}
return(APIServiceResult <T> .OK());
}
catch (Exception ex)
{
logger.Error(ex);
dlgError.ShowDialog(Resources.TemporarilyUnvailable);
return(APIServiceResult <T> .Exception());
}
}
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)));
}
/// <inheritdoc/>
public Task <CouchViewList <TKey, TValue, TSource> > GetDetailedViewAsync <TKey, TValue>(string design, string view,
CouchViewOptions <TKey>?options = null, CancellationToken cancellationToken = default)
{
Check.NotNull(design, nameof(design));
Check.NotNull(view, nameof(view));
IFlurlRequest request = NewRequest()
.AppendPathSegments("_design", design, "_view", view);
Task <CouchViewList <TKey, TValue, TSource> >?requestTask = options == null
? request.GetJsonAsync <CouchViewList <TKey, TValue, TSource> >(cancellationToken)
: request
.PostJsonAsync(options, cancellationToken)
.ReceiveJson <CouchViewList <TKey, TValue, TSource> >();
return(requestTask.SendRequestAsync());
}
/// <inheritdoc/>
public async Task <CouchViewList <TKey, TValue, TSource>[]> GetDetailedViewQueryAsync <TKey, TValue>(string design, string view,
IList <CouchViewOptions <TKey> > queries, CancellationToken cancellationToken = default)
{
Check.NotNull(design, nameof(design));
Check.NotNull(view, nameof(view));
Check.NotNull(queries, nameof(queries));
IFlurlRequest request = NewRequest()
.AppendPathSegments("_design", design, "_view", view, "queries");
CouchViewQueryResult <TKey, TValue, TSource> result =
await request
.PostJsonAsync(new { queries }, cancellationToken)
.ReceiveJson <CouchViewQueryResult <TKey, TValue, TSource> >()
.SendRequestAsync()
.ConfigureAwait(false);
return(result.Results);
}
/// <summary>
/// This method is used to create a bug in Azure Dev Ops.
/// If it cannot create the bug it will rethrow the exception from the DevOps api.
/// Reference: https://docs.microsoft.com/en-us/rest/api/azure/devops/wit/work%20items/create?view=azure-devops-rest-6.0
/// </summary>
/// <param name="branch">Branch for which the bug is being created</param>
/// <param name="build">Build for which the bug is being created</param>
/// <returns>Work item id for the created bug.</returns>
public async Task <string> CreateBugAsync(string branch, VstsBuild build)
{
string requestPath = string.Format(WorkItemPathSegmentFormat, DevOpsAccessSetting.BaseUrl, this.accessSetting.Organization, this.accessSetting.Project);
IFlurlRequest workItemQueryRequest = ((Url)requestPath)
.WithBasicAuth(string.Empty, this.accessSetting.PersonalAccessToken)
.WithHeader("Content-Type", "application/json-patch+json")
.SetQueryParam("api-version", "6.0");
var jsonBody = new object[]
{
new {
op = "add",
path = "/fields/System.Title",
from = string.Empty,
value = $"Test failure on {branch}: {build.DefinitionId.ToString()} {build.BuildNumber}"
},
new
{
op = "add",
path = "/fields/Microsoft.VSTS.TCM.ReproSteps",
from = string.Empty,
value = $"This bug is autogenerated by the vsts-pipeline-sync service. Link to failing build:<div> {build.WebUri}"
},
new
{
op = "add",
path = "/fields/Microsoft.VSTS.Common.Priority",
from = string.Empty,
value = "0"
},
new
{
op = "add",
path = "/fields/System.AreaPath",
from = string.Empty,
value = "One\\IoT\\Platform\\IoTEdge"
},
new
{
op = "add",
path = "/relations/-",
value = new
{
rel = "Hyperlink",
url = $"{build.WebUri}"
}
}
};
JObject result;
try
{
IFlurlResponse response = await workItemQueryRequest
.PostJsonAsync(jsonBody);
result = await response.GetJsonAsync <JObject>();
}
catch (FlurlHttpException e)
{
string message = $"Failed making call to vsts work item 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);
}
return(result["id"].ToString());
}
/// <summary>
/// POST request to the API
/// </summary>
/// <typeparam name="T">Type of return data</typeparam>
/// <param name="dtoForCreation">Data Transfer Object for creating new entity</param>
/// <param name="ReturnData">Flag that indicates data returning</param>
/// <param name="pathToAppend">Additional path to append on base url (e.g. "lock" custom operation as "/users/1/lock")</param>
public async Task <APIServiceResult <T> > Post <T>(object dtoForCreation, bool ReturnData = false,
string pathToAppend = "")
{
try
{
if (!string.IsNullOrWhiteSpace(pathToAppend))
{
request.Url.AppendPathSegment(pathToAppend);
}
HttpResponseMessage response = null;
response = await request.PostJsonAsync(dtoForCreation);
RevertToBaseRequest();
if (response.StatusCode != HttpStatusCode.OK)
{
if (response.StatusCode == HttpStatusCode.Forbidden)
{
}
else if (response.StatusCode == HttpStatusCode.BadRequest)
{
if (response.Content != null)
{
var errorDetails = await response.Content?.ReadAsStringAsync();
return(APIServiceResult <T> .BadRequest(errorDetails));
}
}
else if ((int)response.StatusCode == 422)
{
if (response.Content != null)
{
var errorDetails = await response.Content.ReadAsStringAsync();
var validationProblemDetails =
JsonConvert.DeserializeObject <ValidationProblemDetails>(errorDetails);
if (validationProblemDetails == null)
{
return(APIServiceResult <T> .BadRequest());
}
return(APIServiceResult <T> .BadRequest(validationProblemDetails.Detail));
}
}
return(APIServiceResult <T> .WithStatusCode(response.StatusCode));
}
if (ReturnData)
{
var result = await response.Content.ReadAsAsync <T>();
return(APIServiceResult <T> .OK(result));
}
return(APIServiceResult <T> .OK());
}
catch (Exception ex)
{
return(APIServiceResult <T> .Exception());
}
}
private async Task <ServiceResult <TResult> > ResolveHttpResponseAsync <TResult>(DoType type, int retryCount, IFlurlRequest webApiObject, object bodyObject = null, int secondsTimeout = 30, string callerMemberName = null)
{
var _retMessage = "";
ReturnMessage _message;
HttpResponseMessage _exec = null;
HttpStatusCode _HttpStatusCode = HttpStatusCode.BadRequest;
var _policyResult = await Policy
.Handle <FlurlHttpTimeoutException>().Or <FlurlHttpException>().Or <Exception>()
.RetryAsync(retryCount, (exception, retryNumber) =>
{
System.Diagnostics.Debug.WriteLine($"==================================================================");
System.Diagnostics.Debug.WriteLine($"Method: {callerMemberName} -> Retry: number#{retryNumber} -> exception:{exception.Message}");
System.Diagnostics.Debug.WriteLine($"==================================================================");
})
.ExecuteAndCaptureAsync(new Func <Task <ServiceResult <TResult> > >(async() =>
{
var _token = this.GetCancelationToken(secondsTimeout).Token;
var _content = "";
#if DEBUG
var _json = JsonConvert.SerializeObject(bodyObject);
#endif
switch (type)
{
case DoType.Get:
_exec = await webApiObject.GetAsync(_token);
break;
case DoType.Post:
_exec = await webApiObject.PostJsonAsync(bodyObject, _token);
break;
case DoType.Put:
_exec = await webApiObject.PutJsonAsync(bodyObject, _token);
break;
case DoType.Delete:
_exec = bodyObject == null ? await webApiObject.DeleteAsync(_token) : await webApiObject.SendJsonAsync(HttpMethod.Delete, bodyObject, _token);
break;
}
switch (_exec.StatusCode)
{
case HttpStatusCode.OK:
switch (type)
{
case DoType.Get:
case DoType.Post:
case DoType.Put:
// lê o retorno do serviço
var _stringContent = await _exec.Content.ReadAsStringAsync();
// checa se está nulo, se estiver manda uma string vazia
_stringContent = string.IsNullOrEmpty(_stringContent) ? "" : _stringContent;
// vê se o conteúdo é um json, se não for, formatamos para que seja
TResult _result = default(TResult);
if (this.IsValidJson(_stringContent))
{
_result = JsonConvert.DeserializeObject <TResult>(_stringContent);
}
else
{
_result = (TResult)Convert.ChangeType(_stringContent, typeof(TResult), CultureInfo.CurrentCulture);
}
// retornamos o resultado deserializando no formato informado
return(new ServiceResult <TResult>(_result, true, _exec.StatusCode));
case DoType.Delete:
object _RetBool = true;
return(new ServiceResult <TResult>((TResult)_RetBool, true, _exec.StatusCode));
}
break;
case HttpStatusCode.Unauthorized:
_retMessage = $"Você não está autorizado a executar essa rotina: {callerMemberName}!\r\nPor favor contacte o suporte.";
break;
case HttpStatusCode.InternalServerError:
case HttpStatusCode.BadRequest:
_content = await _exec.Content.ReadAsStringAsync();
try
{
_message = JsonConvert.DeserializeObject <ReturnMessage>(_content);
_retMessage = _message.Message;
}
catch (Exception)
{
_retMessage = _content;
}
break;
case HttpStatusCode.NoContent:
return(new ServiceResult <TResult>(default(TResult), false, _exec.StatusCode));
case HttpStatusCode.NotFound:
return(new ServiceResult <TResult>(default(TResult), false, _exec.StatusCode));
default:
_content = await _exec.Content.ReadAsStringAsync();
_message = JsonConvert.DeserializeObject <ReturnMessage>(_content);
_retMessage = $"Ocorreu um erro ao executar operação na rotina {callerMemberName}!\r\nPor favor contacte o suporte:\r\n\r\n{_message.Message}";
break;
}
_HttpStatusCode = _exec.StatusCode;
return(new ServiceResult <TResult>(default(TResult), false, _HttpStatusCode, _retMessage));
}));
if (_policyResult.Outcome == OutcomeType.Successful)
{
return(_policyResult.Result);
}
else
{
switch (_policyResult.FinalException)
{
case FlurlHttpTimeoutException fhtex:
_HttpStatusCode = HttpStatusCode.GatewayTimeout;
_retMessage = $"O tempo para execução desta tarefa expirou!Rotina{callerMemberName}\r\nTente novamente em alguns segundos.";
break;
case FlurlHttpException fhex:
string _retString = fhex.Message;
if (fhex.Call.HttpStatus.HasValue)
{
_HttpStatusCode = fhex.Call.HttpStatus.Value;
switch (fhex.Call.HttpStatus.Value)
{
case HttpStatusCode.InternalServerError:
case HttpStatusCode.BadRequest:
_retMessage = fhex.Call.Response.Content.ReadAsStringAsync().Result;
break;
}
}
else
{
//_retMessage = $"Ocorreu um erro ao executar a operação na rotina {callerMemberName}!\r\nPor favor contacte o suporte:\r\n\r\n{_retString}";
_retMessage = $"Não foi possível executar a sua solicitação. Verifique a sua conexão com a Internet e tente novamente.";
}
break;
case Exception ex:
_retMessage = this.GetInnerExceptionMessages(ex);
break;
default:
_retMessage = this.GetInnerExceptionMessages(_policyResult.FinalException);
break;
}
return(new ServiceResult <TResult>(default(TResult), false, _HttpStatusCode, _retMessage));
}
}
public static Task <T> PostJsonAsync <T>(this IFlurlRequest request, object data, CancellationToken cancellation) => request.PostJsonAsync(data, cancellation).ReceiveJson <T>();
public async static Task <SdrcFlurHttpResponse <T> > SdrcPostJsonAsync <T>(this IFlurlRequest flurlRequest, object data, CancellationToken cancellationToken = default(CancellationToken), HttpCompletionOption completionOption = HttpCompletionOption.ResponseContentRead) => await SdrcHttpCallAsync(flurlRequest, () => flurlRequest.PostJsonAsync(data, cancellationToken, completionOption).ReceiveJson <T>()).ConfigureAwait(false);
/// <summary>
/// This method is used to create a bug in Azure Dev Ops.
/// If it cannot create the bug it will rethrow the exception from the DevOps api.
/// Reference: https://docs.microsoft.com/en-us/rest/api/azure/devops/wit/work%20items/create?view=azure-devops-rest-6.0
/// </summary>
/// <param name="branch">Branch for which the bug is being created</param>
/// <param name="build">Build for which the bug is being created</param>
/// <returns>Work item id for the created bug.</returns>
public async Task <string> CreateBugAsync(string branch, VstsBuild build)
{
string requestPath = string.Format(WorkItemPathSegmentFormat, DevOpsAccessSetting.BaseUrl, DevOpsAccessSetting.AzureOrganization, DevOpsAccessSetting.AzureProject);
IFlurlRequest workItemQueryRequest = ((Url)requestPath)
.WithBasicAuth(string.Empty, this.accessSetting.MsazurePAT)
.WithHeader("Content-Type", "application/json-patch+json")
.SetQueryParam("api-version", "6.0");
(string bugOwnerFullName, string bugOwnerEmail) = await this.GetBugOwnerInfoAsync(build.SourceVersion);
string bugDescription = GenerateBugDescription(bugOwnerFullName, bugOwnerEmail, build);
var jsonBody = new object[]
{
new
{
op = "add",
path = "/fields/System.Title",
from = string.Empty,
value = $"Test failure on {branch}: {build.DefinitionId.ToString()} {build.BuildNumber}"
},
new
{
op = "add",
path = "/fields/Microsoft.VSTS.TCM.ReproSteps",
from = string.Empty,
value = bugDescription
},
new
{
op = "add",
path = "/fields/Microsoft.VSTS.Common.Priority",
from = string.Empty,
value = "0"
},
new
{
op = "add",
path = "/fields/System.AreaPath",
from = string.Empty,
value = "One\\IoT\\Platform and Devices\\IoTEdge"
},
new
{
op = "add",
path = "/relations/-",
value = new
{
rel = "Hyperlink",
url = $"{build.WebUri}"
}
},
new
{
op = "add",
path = "/fields/System.AssignedTo",
value = bugOwnerEmail
},
new
{
op = "add",
path = "/fields/System.Tags",
value = "auto-pipeline-failed"
}
};
JObject result;
try
{
IFlurlResponse response = await workItemQueryRequest
.PostJsonAsync(jsonBody);
result = await response.GetJsonAsync <JObject>();
}
catch (FlurlHttpException e)
{
string message = $"Failed making call to vsts work item 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);
}
return(result["id"].ToString());
}
private static async Task <TOut> SendAsync <TOut>(IFlurlRequest flurlRequest, WebRequestContext requestContext)
{
TOut result = default;
try
{
requestContext.AttemptCnt++;
if (requestContext.MethodType == WebMethodType.GET)
{
if (requestContext.SerializeType == SerializeType.Json)
{
result = await flurlRequest.GetJsonAsync <TOut>();
}
else
{
var rawData = await flurlRequest.GetBytesAsync();
result = MessagePackSerializer.Deserialize <TOut>(rawData);
}
}
else if (requestContext.MethodType == WebMethodType.POST)
{
if (requestContext.SerializeType == SerializeType.Json)
{
result = await flurlRequest
.PostJsonAsync((string)requestContext)
.ReceiveJson <TOut>();
}
else
{
var rawData = await flurlRequest
.PostAsync(new ByteArrayContent(requestContext))
.ReceiveBytes();
result = MessagePackSerializer.Deserialize <TOut>(rawData);
}
}
}
catch (FlurlHttpException flurlException)
{
if (requestContext.AttemptCnt < WebConfig.ReTryCount)
{
result = await RequestRetryPolicy <TOut>(flurlException, flurlRequest, requestContext);
}
else
{
if (_exceptionHandler != null)
{
await _exceptionHandler.Invoke(flurlException);
}
}
}
catch (Exception ex)
{
if (_exceptionHandler != null)
{
await _exceptionHandler.Invoke(ex);
}
}
return(result);
}
