public async Task <HttpResponseMessage> Delete(string id)
        {
            // Delete subscription
            await _subscriptionService.DeleteAsync(UserId, id);

            return(Request.CreateResponse(HttpStatusCode.OK));
        }
        public async Task <IActionResult> Delete(int id)
        {
            var result = await _subscriptionService.DeleteAsync(id);

            if (!result.Sucess)
            {
                return(BadRequest(result.Message));
            }

            return(Ok("Delete"));
        }
Exemple #3
0
        public void GivenDeleteAsyncWhenExpectedExceptionIsThrownThenHandlesGracefully()
        {
            // Arrange

            // Act
            var exception = Assert.ThrowsAsync <NotImplementedException>(
                () => subscriptionService.DeleteAsync(It.IsAny <Guid>()));

            // Assert
            exception.Should().NotBeNull().And.BeOfType <NotImplementedException>();
        }
        public async Task <IActionResult> DeleteAsync(int id)
        {
            var result = await _subscriptionService.DeleteAsync(id);

            if (!result.Success)
            {
                return(BadRequest(result.Message));
            }
            var subscriptionResource = _mapper.Map <Subscription, SubscriptionResource>(result.Resource);

            return(Ok(subscriptionResource));
        }
Exemple #5
0
        public void GivenDeleteAsyncWhenExpectedExceptionIsThrownThenHandlesGracefully()
        {
            // Arrange

            // Act
            var exception = Assert.ThrowsAsync <NotImplementedException>(
                () => subscriptionService.DeleteAsync(It.IsAny <Guid>()));

            // Assert
            Assert.That(exception, Is.Not.Null);
            Assert.That(exception, Is.TypeOf <NotImplementedException>());
        }
Exemple #6
0
        internal async Task GivenDeleteAsyncWhenExpectedExceptionIsThrownThenHandlesGracefully()
        {
            // Arrange

            // Act
            var exception = await Assert.ThrowsAsync <NotImplementedException>(
                () => subscriptionService.DeleteAsync(It.IsAny <Guid>()));

            // Assert
            Assert.NotNull(exception);
            Assert.IsType <NotImplementedException>(exception);
        }
        public async Task <IActionResult> DeleteAsync([FromRoute] Guid id)
        {
            try
            {
                await subscriptionService.DeleteAsync(id);

                return(NoContent());
            }
            catch (ApplicationException)
            {
                return(NotFound());
            }
            catch
            {
                return(BadRequest());
            }
        }
 public async Task <IActionResult> DeleteSubscription(string id)
 {
     return(Ok(await _serviceReference.DeleteAsync(id)));
 }
Exemple #9
0
        public async Task <IActionResult> DeleteSubscriptionsByIds([FromQuery] string[] ids)
        {
            await _subscriptionService.DeleteAsync(ids);

            return(NoContent());
        }
Exemple #10
0
        public async Task <IActionResult> DeleteAsync(string id, [Required][FromHeader(Name = "User-Id")] string userId)
        {
            var isDeleted = await _subscriptionService.DeleteAsync(id, userId);

            return(!isDeleted?BadRequest() : (IActionResult)Ok());
        }