/// <inheritdoc />
public async Task <TSource> AddOrUpdateAsync(TSource document, bool batch = false, CancellationToken cancellationToken = default)
{
Check.NotNull(document, nameof(document));
if (string.IsNullOrEmpty(document.Id))
{
throw new InvalidOperationException("Cannot add or update a document without an ID.");
}
IFlurlRequest request = NewRequest()
.AppendPathSegment(document.Id);
if (batch)
{
request = request.SetQueryParam("batch", "ok");
}
DocumentSaveResponse response = await request
.PutJsonAsync(document, cancellationToken)
.ReceiveJson <DocumentSaveResponse>()
.SendRequestAsync()
.ConfigureAwait(false);
document.ProcessSaveResponse(response);
await UpdateAttachments(document, cancellationToken)
.ConfigureAwait(false);
return(document);
}
/// <summary>
/// UPDATE request to the API
/// </summary>
/// <typeparam name="T">Type of return data</typeparam>
/// <param name="id">Unique identifier of entity that will be updated</param>
/// <param name="dtoForUpdate">Data Transfer Object for updating entity</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> > Update <T>(int id, object dtoForUpdate, string pathToAppend = "")
{
try
{
request.Url.AppendPathSegment(id);
if (!string.IsNullOrWhiteSpace(pathToAppend))
{
request.Url.AppendPathSegment(pathToAppend);
}
var response = await request.PutJsonAsync(dtoForUpdate);
RevertToBaseRequest();
if (response.StatusCode != HttpStatusCode.OK)
{
if (response.StatusCode == HttpStatusCode.Forbidden)
{
dlgError.ShowDialog(Resources.AccessDenied);
}
else if (response.StatusCode == HttpStatusCode.BadRequest)
{
var msg = string.Empty;
if (response.Content != null)
{
msg = await response.Content.ReadAsStringAsync();
}
dlgError.ShowDialog(msg);
}
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));
}
var headers = response.Headers;
var result = await response.Content.ReadAsAsync <T>();
return(APIServiceResult <T> .OK(result));
}
catch (Exception ex)
{
logger.Error(ex);
dlgError.ShowDialog(Resources.TemporarilyUnvailable);
return(APIServiceResult <T> .Exception());
}
}
public async Task <Result> UpdateDNSRecordAsync(string domainName, DigitalOceanUpdateDomainRecordRequest request, string token, CancellationToken cancellation)
{
string path = string.Format(_updateDNSRecordFormat, domainName, request.Id);
IFlurlRequest httpRequest = BuildRequest(token, path);
IFlurlResponse response = await httpRequest.PutJsonAsync(request, cancellation);
HttpResponseMessage message = response.ResponseMessage;
if (message.IsSuccessStatusCode)
{
return(Result.Ok().WithSuccess(string.Format(_updateDNSRecordsSuccessMessageTemplate, domainName, request.Name)));
}
return(Result.Fail(string.Format(_updateDNSRecordsFailureMessageTemplate, request.Name, domainName)));
}
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)));
}
/// <summary>
/// UPDATE request to the API
/// </summary>
/// <typeparam name="T">Type of return data</typeparam>
/// <param name="id">Unique identifier of entity that will be updated</param>
/// <param name="dtoForUpdate">Data Transfer Object for updating entity</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> > Update <T>(int id, object dtoForUpdate, string pathToAppend = "")
{
try
{
request.Url.AppendPathSegment(id);
if (!string.IsNullOrWhiteSpace(pathToAppend))
{
request.Url.AppendPathSegment(pathToAppend);
}
HttpResponseMessage response = null;
response = await request.PutJsonAsync(dtoForUpdate);
RevertToBaseRequest();
if (response.StatusCode != HttpStatusCode.OK)
{
if ((int)response.StatusCode == 422 || response.StatusCode == HttpStatusCode.BadRequest)
{
if (response.Content != null)
{
var errorMessage = await response.Content.ReadAsStringAsync();
return(APIServiceResult <T> .WithStatusCode((HttpStatusCode)422, errorMessage));
}
}
return(APIServiceResult <T> .WithStatusCode(response.StatusCode));
}
var result = await response.Content.ReadAsAsync <T>();
return(APIServiceResult <T> .OK(result));
}
catch (Exception ex)
{
return(APIServiceResult <T> .Exception());
}
}
/// <summary>
/// Creates or updates the document with the given ID.
/// </summary>
/// <param name="document">The document to create or update</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 or updated.</returns>
public async Task <TSource> CreateOrUpdateAsync(TSource document, bool batch = false)
{
if (string.IsNullOrEmpty(document.Id))
{
throw new InvalidOperationException("Cannot add or update a document without an ID.");
}
IFlurlRequest request = NewRequest()
.AppendPathSegment(document.Id);
if (batch)
{
request = request.SetQueryParam("batch", "ok");
}
DocumentSaveResponse response = await request
.PutJsonAsync(document)
.ReceiveJson <DocumentSaveResponse>()
.SendRequestAsync()
.ConfigureAwait(false);
document.ProcessSaveResponse(response);
return(document);
}
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));
}
}
