public async Task <IActionResult> Delete([FromRoute] string userId)
{
DeleteSubscriptionCommand command = new DeleteSubscriptionCommand(userId);
await _mediator.Send(command);
return(StatusCode(StatusCodes.Status200OK));
}
public async Task <IActionResult> Delete(
[FromRoute] string email,
CancellationToken ct = default)
{
var command = new DeleteSubscriptionCommand(email);
await Mediator.Send(command, ct);
return(NoContent());
}
public void WhenEntityDoesNotExists_ThenThrowEntityNotFound()
{
var entityById = Mock.Of <IEntityById>(eb => eb.Exist <Subscription>(It.IsAny <Identity>()) == false);
var command = new DeleteSubscriptionCommand(entityById, Mock.Of <IRepository <Subscription> >());
var identity = Identity.Random();
command.Executing(c => c.Execute(identity))
.Throws <EntityNotFoundException>();
}
public async Task DeleteAsync(string name, string database = null)
{
JsonOperationContext jsonOperationContext;
var requestExecutor = _store.GetRequestExecutor(database ?? _store.Database);
requestExecutor.ContextPool.AllocateOperationContext(out jsonOperationContext);
var command = new DeleteSubscriptionCommand(name);
await requestExecutor.ExecuteAsync(command, jsonOperationContext).ConfigureAwait(false);
}
/// <summary>
/// Delete a subscription.
/// </summary>
public async Task DeleteAsync(string name, string database = null, CancellationToken token = default)
{
(_store as DocumentStoreBase).AssertInitialized();
var requestExecutor = _store.GetRequestExecutor(database ?? _store.Database);
requestExecutor.ContextPool.AllocateOperationContext(out JsonOperationContext jsonOperationContext);
var command = new DeleteSubscriptionCommand(name);
await requestExecutor.ExecuteAsync(command, jsonOperationContext, sessionInfo : null, token : token).ConfigureAwait(false);
}
public async Task <ActionResult> Unsubscribe(long courseId, DeleteSubscriptionCommand command)
{
if (courseId != command.CourseId)
{
return(BadRequest());
}
await Mediator.Send(command);
return(Ok());
}
public async Task DeleteAsync(long id, string database = null)
{
JsonOperationContext jsonOperationContext;
var requestExecuter = documentStore.GetRequestExecuter(database ?? documentStore.DefaultDatabase);
requestExecuter.ContextPool.AllocateOperationContext(out jsonOperationContext);
var command = new DeleteSubscriptionCommand(id);
await requestExecuter.ExecuteAsync(command, jsonOperationContext);
}
public async Task <ActionResult> Delete(Guid id)
{
var command = new DeleteSubscriptionCommand()
{
SubscriptionId = id
};
await _mediator.Send(command);
return(NoContent());
}
public bool Delete([FromBody] int subscriptionId)
{
var command = new DeleteSubscriptionCommand
{
SubscriptionId = subscriptionId
};
_commandSender.Send(command);
return(true);
}
public async Task DeleteSubscription(string name, string raftRequestId)
{
var command = new DeleteSubscriptionCommand(_db.Name, name, raftRequestId);
var(etag, _) = await _serverStore.SendToLeaderAsync(command);
if (_logger.IsInfoEnabled)
{
_logger.Info($"Subscription with id {name} was deleted");
}
await _db.RachisLogIndexNotifications.WaitForIndexNotification(etag, _serverStore.Engine.OperationTimeout);
}
public void Should_delete_subscription()
{
const int subscriptionId = 1;
var command = new DeleteSubscriptionCommand {
SubscriptionId = subscriptionId
};
_handler.Handle(command);
_episodeCommandDataSource.Received(1).DeleteAllFromSubscription(subscriptionId);
_subscriptionCommandDataSource.Received(1).Delete(subscriptionId);
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, HttpMethods.Delete, Route = "notification/{id}")] HttpRequest req,
string id)
{
var deleteSubscriptionCommand = new DeleteSubscriptionCommand(id);
var result = await _subscriptionHandler.DeleteSubscription(deleteSubscriptionCommand);
if (!result.Success)
{
return(new NotFoundResult());
}
return(new NoContentResult());
}
public void WhenAllIsOk_ThenDelete()
{
var identity = Identity.Random();
var entityById = Mock.Of <IEntityById>(eb => eb.Exist <Subscription>(It.IsAny <Identity>()) == true);
var repository = new StubRepository <Subscription>(new Subscription {
Id = identity
});
var command = new DeleteSubscriptionCommand(entityById, repository);
command.Execute(identity);
repository.Entities.Should().Be.Empty();
}
public async Task <IResult> DeleteSubscription(DeleteSubscriptionCommand command)
{
try
{
var registration = await _hubClient.GetRegistrationAsync <RegistrationDescription>(command.RegistrationId);
if (registration == null)
{
return(new FailedResult());
}
await _hubClient.DeleteRegistrationAsync(command.RegistrationId);
return(new SuccessfulResult());
}
catch (Exception exception)
{
_logger.LogError($"{nameof(DeleteSubscription)}: {exception}");
return(new FailedResult());
}
}
public ICommandHandler <DeleteSubscriptionCommand, Task <CommandResponse> > Build(
DeleteSubscriptionCommand command)
{
return(new DeleteSubscriptionCommandHandler(command, _context));
}
public async Task TestAsync(DeleteSubscriptionCommand command)
{
command.Subscription = await GetSubscriptionAsync(command.SubscriptionId);
}
public DeleteSubscriptionCommandHandler(DeleteSubscriptionCommand command, ApplicationDbContext dbContext) : base(dbContext)
{
_command = command;
}
public async Task <IActionResult> UnSubscribe([FromServices] SubscriptionCommandHandlerFactory commandHandlerFactory, DeleteSubscriptionCommand command)
{
command.AccountId = _userManager.GetUserId(User);
var handler = commandHandlerFactory.Build(command);
var response = await handler.Execute();
return(Ok());
}
