/// <inheritdoc />
/// <summary>
/// Uninitializes the Chroma SDK by sending a DELETE request to <c>/</c>.
/// </summary>
/// <returns>A <see cref="Task" /> representing the asynchronous operation.</returns>
/// <exception cref="RestException">Thrown if there is an error calling the REST API.</exception>
/// <exception cref="ApiException">Thrown if the SDK responds with an error code.</exception>
public async Task UninitializeAsync()
{
var response = await _client.DeleteAsync <SdkResponse>("/").ConfigureAwait(false);
if (!response.IsSuccessful)
{
Log.Error("Chroma SDK uninitialization failed");
throw new RestException(
"Failed to uninitialize Chroma REST API",
response.Data?.Result ?? Result.RzFailed,
new Uri(_client.BaseAddress, "/"),
response.Status,
response.Data?.ToString());
}
var data = response.Data;
if (data == null)
{
throw new ApiException("Uninitialize API returned NULL response");
}
if (!data.Result)
{
throw new ApiException("Exception when calling uninitialize API", data.Result);
}
Log.Debug("Stopping heartbeat timer");
_heartbeatTimer.Change(Timeout.Infinite, Timeout.Infinite);
}
public async Task Should_Throw_Should_Throw_ArgumentException_If_Path_Is_Null_Or_Empty()
{
IRestClient _restClient = CreateRestClient();
await Assert.ThrowsAsync <ArgumentNullException>(() => _restClient.DeleteAsync <DeleteUserResponse>(null)).ConfigureAwait(false);
await Assert.ThrowsAsync <ArgumentException>(() => _restClient.DeleteAsync <DeleteUserResponse>(string.Empty)).ConfigureAwait(false);
}
// AJAX: /ShoppingCart/RemoveFromCart/5
public async Task <IActionResult> RemoveFromCart(int id, CancellationToken requestAborted)
{
// Remove from cart
await _IRestClient.DeleteAsync($"{baseUrl}/Basket/{_cookieLogic.GetBasketId()}/item/{id}");
TempData[ToastrMessage.Success] = "Successfully Removed Song";
return(RedirectToAction("Index"));
}
/// <summary>
/// Execute request
/// </summary>
/// <param name="values">List of parameters for request (content)</param>
/// <returns>RestResponse</returns>
public async Task <RestResponse <T> > Execute(IEnumerable <KeyValuePair <string, string> > values)
{
HttpContent content = null;
if (values != null)
{
if (values is Dictionary <string, string> )
{
content = new StringContent(JsonConvert.SerializeObject(values), Encoding.UTF8, "application/json");
}
else
{
content = new FormUrlEncodedContent(values);
}
}
HttpResponseMessage message = null;
switch (_method)
{
case Method.GET:
message = await _client.GetAsync(_path);
break;
case Method.POST:
message = await _client.PostAsync(_path, content);
break;
case Method.PUT:
message = await _client.PutAsync(_path, content);
break;
case Method.DELETE:
if (content == null)
{
message = await _client.DeleteAsync(_path);
}
else
{
message = await _client.DeleteAsync(_path, content);
}
break;
}
RestResponse <T> response = new RestResponse <T>(message);
return(response);
}
public async Task DeleteAsync_ExecutesRetryPolicyAsExpected()
{
// Expect the parameters to be passed to the method of the inner rest client.
// We'll throw an exception from within the callback method to trigger retries.
this.mockRestClient
.Setup(c => c.DeleteAsync(
It.Is <EndpointName>(e => e.Equals(this.endpointName)),
It.Is <IEnumerable <int> >(j => j.Equals(this.deleteIds)),
It.Is <LogContext>(l => l.Equals(this.logContext)),
It.IsAny <CancellationToken>()))
.Callback((EndpointName en, IEnumerable <int> di, LogContext lc, CancellationToken ct)
=> throw new ServiceUnavailableException("Something went wrong."));
try
{
IRestClient restClient = GetRestClientWithRetries();
await restClient.DeleteAsync(this.endpointName, this.deleteIds, this.logContext, default);
Assert.Fail("Expected exception to be thrown.");
}
catch (ServiceUnavailableException)
{
}
// Verify our inner rest client was called 4 times (original invocation + retries)
this.mockRestClient.Verify(m => m.DeleteAsync(this.endpointName, this.deleteIds, this.logContext, default),
Times.Exactly(RetryCount + 1));
}
public async Task DeleteAsync_FailsOnFirstTryWhenExceptionIsNotHandledByPolicy()
{
// Expect the parameters to be passed to the method of the inner rest client.
// We'll throw an exception from within the callback method to trigger retries.
this.mockRestClient
.Setup(c => c.DeleteAsync(
It.Is <EndpointName>(e => e.Equals(this.endpointName)),
It.Is <IEnumerable <int> >(j => j.Equals(this.deleteIds)),
It.Is <LogContext>(l => l.Equals(this.logContext)),
It.IsAny <CancellationToken>()))
.Callback((EndpointName en, IEnumerable <int> di, LogContext lc, CancellationToken ct)
=> throw new BadRequestException("Bad request."));
try
{
IRestClient restClient = GetRestClientWithRetries();
await restClient.DeleteAsync(this.endpointName, this.deleteIds, this.logContext, default);
Assert.Fail("Expected exception to be thrown.");
}
catch (BadRequestException)
{
}
// Verify our inner rest client was called exactly once.
this.mockRestClient.Verify(m => m.DeleteAsync(this.endpointName, this.deleteIds, this.logContext, default),
Times.Once);
}
public async Task Should_Return_DeleteUserResponse()
{
const string path = "/api/users/[email protected]";
const string content = "{\"msg\": \"test message\",\"code\": \"Success\"}";
IRestClient _restClient = CreateRestClient(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(content)
});
ApiResponse <DeleteUserResponse> apiResponse = await _restClient.DeleteAsync <DeleteUserResponse>(path).ConfigureAwait(false);
Assert.NotNull(apiResponse);
Assert.Equal(HttpStatusCode.OK, apiResponse.HttpStatusCode);
Assert.Equal(path, apiResponse.UrlPath);
Assert.NotNull(apiResponse.Headers);
Assert.Equal(1, apiResponse.Headers.Count);
Assert.NotNull(apiResponse.Model);
Assert.IsType <DeleteUserResponse>(apiResponse.Model);
Assert.Equal("test message", apiResponse.Model.Msg);
Assert.Equal("Success", apiResponse.Model.Code);
VerifyRestClient(Times.Once(), HttpMethod.Delete, path);
}
public async Task Should_Throw_ArgumentException_If_Request_Is_Null_Or_Empty()
{
const string path = "/api/users/delete";
IRestClient _restClient = CreateRestClient();
await Assert.ThrowsAsync <ArgumentNullException>(() => _restClient.DeleteAsync <DeleteUserResponse>(path, null)).ConfigureAwait(false);
}
public Task CancelComputationAsync(ApiSession apiSession, string computationId, CancellationToken cancellationToken)
{
if (apiSession == null)
{
throw new ArgumentNullException(nameof(apiSession));
}
if (computationId == null)
{
throw new ArgumentNullException(nameof(computationId));
}
var spaceName = apiSession.SpaceName;
var url = UrlHelper.JoinUrl("space", spaceName, "computations", computationId);
return(apiClient.DeleteAsync <NoContentRequest>(url, null, apiSession.ToHeadersCollection(), cancellationToken));
}
public static Task <T> DeleteAsync <T>(
this IRestClient client,
string requestUri,
CancellationToken cancellationToken = default)
{
return(client.DeleteAsync <T>(new Uri(requestUri), cancellationToken));
}
private async Task ExecuteDeleteCommand()
{
if (!await _dialog.DisplayAlertAsync($"Delete {AlterEgo}", "Are you sure?", "Cancel", "OK"))
{
return;
}
IsBusy = true;
try
{
var status = await _client.DeleteAsync($"superheroes/{Id}");
if (status != HttpStatusCode.NoContent)
{
await _dialog.DisplayAlertAsync("Error", $"Error from api: {status}", "OK");
}
else
{
_messaging.Send(this, DeleteSuperhero, Id);
await _navigation.BackAsync();
}
}
catch (Exception e)
{
await _dialog.DisplayAlertAsync(e);
}
IsBusy = false;
}
public async Task <IResult> DeleteCustomer(Guid customerId)
{
if (customerId == null || customerId == Guid.Empty)
{
throw new UnableToUpdateCustomerDetailsException(
$"Unable To Updated customer details for customer. No details provided.");
}
try
{
using (var request = CreateRequestMessage())
{
request.Headers.Remove("version");
request.Headers.Add("version", _dssSettings.Value.DigitalIdentitiesPatchByCustomerIdApiVersion);
_logger.LogInformation($"call to {_dssSettings.Value.DigitalIdentitiesPatchByCustomerIdApiUrl.Replace(CustomerIdTag, customerId.ToString())} made");
_logger.LogInformation($" Request contains the following headers{string.Join(",", request.Headers)}");
await _restClient.DeleteAsync(
apiPath : $"{_dssSettings.Value.DigitalIdentitiesPatchByCustomerIdApiUrl.Replace(CustomerIdTag, customerId.ToString())}", request);
}
if (!_restClient.LastResponse.IsSuccess)
{
throw new UnableToUpdateCustomerDetailsException(
$"Unable To Updated customer details for customer {customerId}, Response {_restClient.LastResponse.Content}");
}
return(Result.Ok());
}
catch (Exception e)
{
throw new UnableToUpdateCustomerDetailsException(
$"Unable To Updated customer details for customer {customerId}, Response {_restClient.LastResponse.Content}");
}
}
public async Task <IActionResult> RemoveCart()
{
var basketId = Request.Query["id"];
await _IRestClient.DeleteAsync($"{baseUrl}/Basket/{basketId}");
TempData[ToastrMessage.Success] = "Successfully Removed Shopping Cart";
return(RedirectToAction("Index"));
}
public async Task <Todo> DeleteAsync(Todo todo)
{
RestRequest restRequest = new RestRequest("/" + todo.Id);
restRequest.AddHeader("Content-Type", "application/json");
var response = await restClient.DeleteAsync <Todo>(restRequest);
return(response);
}
public async Task <IActionResult> DeleteLineItem(string basketId, int productId)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var correlationToken = CorrelationTokenManager.GenerateToken();
// Note: Sending querystring parameters in the post.
var success = await client.DeleteAsync(ServiceEnum.Basket,
$"api/basket/{basketId}/lineitem/{productId}?correlationToken={correlationToken}");
if (success)
{
return(NoContent());
}
return(NotFound());
}
public async Task <Unit> Handle(Request request, CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var restRequest = new RestRequest(new Uri(string.Format(DeleteUserUrlFormat, request.Id), UriKind.Relative));
var response = await restClient.DeleteAsync <ApiResult <User> >(restRequest, cancellationToken).ConfigureAwait(false);
response.GetResult(HttpStatusCode.NoContent);
return(Unit.Value);
}
private IObservable <Unit> ObserveDelete()
{
return(DeleteCommand.ActivateGestures()
.SelectMany(x => _restClient.DeleteAsync(Url).ToObservable(), (x, y) => y)
.Take(1)
.AsUnit()
.Catch <Unit, Exception>(x =>
{
_schedulerService.Dispatcher.Schedule(() => _messageService.Post(Constants.UI.ExceptionTitle, _exceptionFactory(x)));
return ObserveDelete();
}));
}
public async Task <IActionResult> DeleteLineItem(string basketId, int productId)
{
var correlationToken = CorrelationTokenManager.GenerateToken();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Note: Sending querystring parameters in the post.
var success = await _restClient.DeleteAsync(ServiceEnum.Basket,
$"api/basket/{basketId}/lineitem/{productId}", correlationToken);
if (!success)
{
_logger.LogError(LoggingEvents.Checkout, $"Could not delete line item {productId} for Basket {basketId} for Request {correlationToken}");
return(BadRequest($"Could not delete line item {productId} for Basket {basketId} for Request {correlationToken}"));
}
_logger.LogInformation(LoggingEvents.DeleteLineItem, $"Basket: Line item deleted for correlationToken: {correlationToken}");
return(NoContent());
}
private async Task ExecuteDeleteCommand()
{
// TODO: Implement confirm dialog
IsBusy = true;
await _client.DeleteAsync($"superheroes/{Id}");
_messaging.Send(this, DeleteSuperhero, Id);
await _navigation.BackAsync();
IsBusy = false;
}
public async void CrudAsync_NewUser_Success()
{
// Create.
User original = DataFactory.RandomUser;
Response <User> created = await _client.PostAsync <User, User>(content : original);
Assert.Equal(HttpStatusCode.Created, created.StatusCode);
Assert.NotNull(created.Data);
Assert.NotNull(created.Data.Id);
Assert.Equal(original.Email, created.Data.Email);
Assert.Equal(original.FirstName, created.Data.FirstName);
Assert.Equal(original.LastName, created.Data.LastName);
_output.WriteLine($"Created new user:\n{created.Data.ToJson()}");
// Retrieve single.
Response <User> retrieved = await _client.GetAsync <User>(created.Data.Id);
Assert.Equal(HttpStatusCode.OK, retrieved.StatusCode);
Assert.NotNull(retrieved.Data);
Assert.Equal(created.Data.Id, retrieved.Data.Id);
_output.WriteLine($"Retrieved newly created user:\n{retrieved.ToJson()}");
// Update.
const string newMiddleName = "Perry";
User retrievedUser = retrieved.Data;
retrievedUser.MiddleNames = newMiddleName;
Response updatedResponse = await _client.PutAsync(retrievedUser.Id, retrievedUser);
Assert.Equal(HttpStatusCode.OK, updatedResponse.StatusCode);
Response <User> updated = await _client.GetAsync <User>(retrievedUser.Id);
Assert.Equal(HttpStatusCode.OK, updated.StatusCode);
Assert.NotNull(updated.Data);
Assert.Equal(retrievedUser.Id, updated.Data.Id);
Assert.Equal(newMiddleName, updated.Data.MiddleNames);
_output.WriteLine($"Updated the MiddleNames property of the newly created user:\n{updated.ToJson()}");
// Delete.
Response deleteResponse = await _client.DeleteAsync(created.Data.Id);
Assert.Equal(HttpStatusCode.OK, deleteResponse.StatusCode);
Response headResponse = await _client.HeadAsync(created.Data.Id);
Assert.Equal(HttpStatusCode.NotFound, headResponse.StatusCode);
_output.WriteLine($"Successfully deleted user {created.Data.Id}.");
}
/// <summary>
/// Remove previously uploaded payload
/// </summary>
/// <returns>True if successfully removed from server</returns>
public async Task <bool> RemovePayloadAsync()
{
if (payloadID.HasValue)
{
var request = new RestRequest($"payload/{payloadID.Value}");
var response = await client.DeleteAsync <bool>(request);
if (response)
{
payloadID = null;
}
return(response);
}
return(true);
}
public void should_delete_xml_object()
{
// ARRANGE
var url = new Uri(_baseUrl + "/api/employees/1");
// ACT
var task = _xmlRestClient.DeleteAsync(url);
task.Wait();
var response = task.Result;
// ASSIGN
Assert.That(response, Is.Not.Null);
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
}
public async Task<BaseResponse<bool>> HandleAsync(DeleteAccountCommand command, CancellationToken cancellationToken)
{
var endpoint = $"{command.Id}";
var baseResponse = new BaseResponse<bool>()
{
StatusCode = HttpStatusCode.OK,
Errors = string.Empty,
IsSuccess = true,
Result = true
};
var response = await _restClient.DeleteAsync(endpoint);
if (response != HttpStatusCode.NoContent)
{
_logger.LogError($"DeleteCommandHandler/DeleteAsync returned {response}");
}
return baseResponse;
}
public async Task DeleteAsync_SucceedsOnFirstTryWhenNoExceptionIsThrown()
{
// Expect the parameters to be passed to the method of the inner rest client.
// We'll throw an exception from within the callback method to trigger retries.
this.mockRestClient
.Setup(c => c.DeleteAsync(
It.Is <EndpointName>(e => e.Equals(this.endpointName)),
It.Is <IEnumerable <int> >(j => j.Equals(this.deleteIds)),
It.Is <LogContext>(l => l.Equals(this.logContext)),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult("Done."));
IRestClient restClient = GetRestClientWithRetries();
string result = await restClient.DeleteAsync(this.endpointName, this.deleteIds, this.logContext, default);
Assert.AreEqual(SuccessResult, result, $"Expected result: '{SuccessResult}'.");
// Verify our inner rest client was called only once.
this.mockRestClient.Verify(m => m.DeleteAsync(this.endpointName, this.deleteIds, this.logContext, default),
Times.Once);
}
public async Task <RestResponse> Delete(Guid id)
{
return(await _restClient.DeleteAsync($"posts/{id}"));
}
public async Task DeleteAsync()
{
await _restClient.DeleteAsync("api/test/1");
}
public async Task <ApiResponse <DeleteUserResponse> > DeleteByEmailAsync(string email)
{
Ensure.ArgumentNotNullOrEmptyString(email, nameof(email));
return(await _client.DeleteAsync <DeleteUserResponse>($"/api/users/{email}").ConfigureAwait(false));
}
public async Task DeleteAsync(string url)
{
var requestUri = Client.BuildUri(url);
await Client.DeleteAsync <object>(requestUri, null, resource : ResourceName).ConfigureAwait(false);
}
public Task Delete(int Id)
{
var urlstring = url + "/" + 0 + "/" + Id;
return(_restClient.DeleteAsync <Offer>(urlstring));
}
public async Task <bool> RemoveItem(int productId)
{
var response = await _restClient.DeleteAsync($"{baseUrl}/Basket/{GetBasketId()}/item/{productId}");
return(response.Data);
}