public async Task NotifyAsync(int notificationId, CancellationToken cancellationToken)
{
var notification = await _eventNotificationService.GetByIdAsync(notificationId);
if (notification == null)
{
_logger.LogError($"Scheduled notification with Id {notificationId} is not found in database");
return;
}
try
{
var chatId = new ChatId(notification.UserTelegramId);
var msg = await _botClient.SendTextMessageAsync(chatId, notification.Subject, cancellationToken : cancellationToken);
_logger.LogDebug($"Sended scheduled notification {notificationId}");
await _eventNotificationService.DeleteAsync(notificationId);
_logger.LogDebug($"Deleted scheduled notification {notificationId}");
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error sending notification {notificationId}");
throw;
}
}
public virtual async Task <TDto> DeleteAsync(TId id)
{
var deletedEntity = await _service.DeleteAsync(id);
await _repository.SaveChangesAsync();
return(_mapper.Map <TDto>(deletedEntity));
}
public async Task DeleteOrderStatusAsync(int orderId)
{
var orderStatus = await orderStatusService.Where(item => item.OrderId == orderId).ToListAsync();
foreach (var status in orderStatus)
{
await orderStatusService.DeleteAsync(status);
}
}
public async Task DeleteOrderPositionAsync(int orderId)
{
var orderPositions = await orderPositionService.Where(op => op.OrderId == orderId).ToArrayAsync();
foreach (var orderPosition in orderPositions)
{
await orderPositionService.DeleteAsync(orderPosition);
}
}
public async Task <IActionResult> DeleteAsync(int id)
{
if (DeleteWhere(id) != null)
{
var result = await _crudService.DeleteAsync(DeleteWhere(id));
return(Json(result));
}
return(Json(Result.Create(true, 200)));
}
public async Task <IHttpActionResult> DeleteCommentAsync(int?id)
{
if (id == null)
{
return(BadRequest());
}
await _commentService.DeleteAsync(id);
return(Ok());
}
public virtual async Task <ActionResult <T2> > Delete(T1 id)
{
try
{
return(Ok(await _service.DeleteAsync(id)));
}
catch (EntityNotFoundException)
{
return(NotFound());
}
}
public async Task DeleteIngredientsAsync(int productId)
{
var productIngredients = await m_productIngredientService
.Where(item => item.ProductId == productId)
.ToListAsync();
foreach (var item in productIngredients)
{
await m_productIngredientService.DeleteAsync(item);
}
}
public async Task <IActionResult> Delete(Guid id)
{
try
{
return(Ok(await _service.DeleteAsync(id)));
}
catch (EntityNotFoundException ex)
{
return(NotFound());
}
}
public async Task <IActionResult> Delete(int id)
{
if (await _service.ReadAsync(id) == null)
{
_logger.LogInformation($"{nameof(OrdersController)}:{id} not found");
return(NotFound());
}
await _service.DeleteAsync(id);
return(NoContent());
}
public virtual async Task <CustomerOrderAggregate> Handle(CreateOrderFromCartCommand request, CancellationToken cancellationToken)
{
var cart = await _cartService.GetByIdAsync(request.CartId);
await ValidateCart(cart);
var result = await _customerOrderAggregateRepository.CreateOrderFromCart(cart);
await _cartService.DeleteAsync(new List <string> {
request.CartId
}, softDelete : true);
// Remark: There is potential bug, because there is no transaction thru two actions above. If a cart deletion fails, the order remains. That causes data inconsistency.
// Unfortunately, current architecture does not allow us to support such scenarios in a transactional manner.
return(result);
}
/// <summary>
/// Deletes the asynchronous.
/// </summary>
/// <param name="id">The identifier.</param>
/// <returns></returns>
public virtual async Task <T2> DeleteAsync(T1 id)
{
var entity = await _service.DeleteAsync(id);
// store all object in historical event
var historicalEvent = new HistoricalEvent
{
Action = HistoricalActions.Delete.ToString(),
Changeset = new HistoricalChangeset()
{
ObjectData = new T2().DetailedCompare(entity)
},
EntityId = entity.Id.ToString(),
EntityName = entity.GetType().FullName
};
await _repository.CreateAsync <Guid, HistoricalEvent>(historicalEvent);
await _repository.SaveChangesAsync();
return(entity);
}
public async Task <ActionResult <CourseDTO> > DeleteCourse(int id)
{
try
{
var exist = await _crudService.AnyAsync <Course>(s => s.Id.Equals(id));
if (!exist)
{
return(NotFound("Unable to find the related entity"));
}
if (await _crudService.DeleteAsync <Course>(i => i.Id.Equals(id)))
{
return(NoContent());
}
}
catch
{
return(StatusCode(StatusCodes.Status500InternalServerError,
"Failed to add the entity"));
}
return(BadRequest("Cannot delete this item!"));
}
public async Task <IActionResult> DeleteAsync(int id, CancellationToken cancellationToken = default)
{
await _crudService.DeleteAsync(id);
return(NoContent());
}
public async Task <ActionResult> DeleteAsync(Guid id)
{
await _studentCrudService.DeleteAsync(id);
return(Ok());
}
public async Task <ActionResult> Delete([FromQuery] string[] ids)
{
await _customerReviewService.DeleteAsync(ids);
return(NoContent());
}
public virtual Task RemoveCartAsync(string cartId) => _shoppingCartService.DeleteAsync(new[] { cartId }, softDelete: true);
public async Task HandleAsync(DeleteEntityCommand <TEntity> command)
{
await _crudService.DeleteAsync(command.Entity);
}
public async Task <T2> DeleteAsync(T1 id) => await _service.DeleteAsync(id);
public async Task Delete([FromRoute] string id) => await _service.DeleteAsync(id);
public async Task HandleAsync(DeleteEntityCommand <TEntity> command, CancellationToken cancellationToken = default)
{
await _crudService.DeleteAsync(command.Entity);
}
public virtual async Task <T> DeleteAsync(Guid id) => await _service.DeleteAsync(id);
public async Task HandleAsync(DeleteProductCommand command, CancellationToken cancellationToken = default)
{
await _productService.DeleteAsync(command.Product);
}
public async Task HandleAsync(DeleteProductCommand command)
{
await _productService.DeleteAsync(command.Product);
}
public virtual async Task <IActionResult> DeleteAsync(string id)
{
await _service.DeleteAsync(id);
return(Success());
}
public async Task <IHttpActionResult> DeleteAsync([FromUri] Guid id) => await ExecuteAsync(async() => await _crudService.DeleteAsync(id));