public bool Delete(int id)
{
var sale = _repository.FindById(id);
_repository.Delete(sale);
return(_repository.SaveChanges());
}
public async Task <bool> Handle(DeleteSaleCommand request, CancellationToken cancellationToken)
{
if (!request.IsValid())
{
NotifyValidationErrors(request);
return(false);
}
var sale = _saleRepository.FindById(request.Id);
if (sale == null)
{
await _bus.Publish(new ExceptionNotification("056", "Não foi encontrado nenhuma promoção com este Id"),
cancellationToken);
return(false);
}
_saleRepository.Delete(sale);
if (await Commit())
{
return(true);
}
await _bus.Publish(new ExceptionNotification("056", "Não foi possível realizar a remoção desse cupom"),
cancellationToken);
return(false);
}
public IActionResult DeleteSale(int saleId)
{
var item = this.saleRepository.Find(saleId);
saleRepository.Delete(item);
return(RedirectToAction("index"));
}
public void Delete(Sale sale)
{
if (sale.Id <= 0)
{
throw new InvalidIdException();
}
_repository.Delete(sale.Id);
}
public void SaleRepository_Delete_ShouldBeOk()
{
var id = 1;
_repository.Delete(id);
_expectedSale = _repository.Get(id);
_expectedSale.Should().BeNull();
}
public void Delete(Sale sale)
{
if (sale.Id < 1)
{
throw new IdentifierUndefinedException();
}
_repositorio.Delete(sale);
}
public async Task <SaleResponse> DeleteAsync(Sale sale)
{
if (_saleRepository.GetById(sale.ID) == null)
{
return(new SaleResponse("Object With Specific ID Was Null"));
}
try
{
_saleRepository.Delete(sale);
await _unitOfWork.CompleteAsync();
return(new SaleResponse(sale));
}
catch (Exception ex)
{
// Do some logging stuff
return(new SaleResponse($"An error occurred when deleting the Sale: {ex.Message}"));
}
}
public ViewModelSale Delete(ViewModelSale vSale)
{
try
{
_iSaleRepository.Delete(vSale.Id);
_iSaleRepository.Save();
return(vSale);
}
catch (Exception e)
{
return(null);
}
}
public void SaleSqlRepository_Delete_ShoulBeOK()
{
//Cenario
Sale sale = ObjectMother.GetSale();
sale.Product = new Product
{
Id = 1,
Name = "Rice",
SalePrice = 6,
CostPrice = 2,
Disponibility = true,
FabricationDate = DateTime.Now,
ExpirationDate = DateTime.Now.AddMonths(4)
};
sale.Id = 1;
//Executa
_repository.Delete(sale);
Sale deleteObject = _repository.Get(1);
//Verifica
deleteObject.Should().BeNull();
}
public IActionResult Delete(int id)
{
Sale _saleDb = _saleRepository.GetSingle(id);
if (_saleDb == null)
{
return(new NotFoundResult());
}
else
{
_saleRepository.Delete(_saleDb);
_saleRepository.Commit();
return(new NoContentResult());
}
}
public async Task <ActionResult> Delete(int id)
{
Sale order = await saleRepository.GetAsync(id);
if (order == null)
{
return(NotFound());
}
if (!saleRepository.Delete(order))
{
string message = $"Deleting a sale {id} failed on save.";
logger.LogWarning(message);
return(BadRequest(message));
}
return(NoContent());
}
public async Task <SaleResponse> DeleteAsync(int id)
{
var existingSale = await saleRepository.FindById(id);
if (existingSale == null)
{
return(new SaleResponse("User not found"));
}
try
{
saleRepository.Delete(existingSale);
await unitOfWork.CompleteAsync();
return(new SaleResponse(existingSale));
}
catch (Exception ex)
{
return(new SaleResponse($"Error when deleting sale: {ex.Message}"));
}
}
private void btnDelete_Click(object sender, EventArgs e)
{
if (cbTables.SelectedIndex == 0)
{
Product currentProduct = (Product)productSource.Current;
productConnection.Delete(currentProduct);
MessageBox.Show("Successfully deleted the product!");
}
else if (cbTables.SelectedIndex == 1)
{
Client currentClient = (Client)clientSource.Current;
clientConnection.Delete(currentClient);
MessageBox.Show("Successfully deleted the client!");
}
else if (cbTables.SelectedIndex == 2)
{
Sale currentSale = (Sale)saleSource.Current;
saleConnection.Delete(currentSale);
MessageBox.Show("Successfully deleted the sale!");
}
btnShow.PerformClick();
}
public async Task <object> Delete(int id)
{
Sale sale = new Sale();
try
{
sale = _saleRepository.Delete(id);
}
catch (Exception ex)
{
result = false;
error = ex.Message;
}
return(new SingleResponse <Sale>
{
Message = "Sale deleted successfully",
DidError = false,
ErrorMessage = string.Empty,
Token = string.Empty,
Model = sale
});
}
public IActionResult Delete(int id)
{
_saleRepository.Delete(id);
return(RedirectToAction("index"));
}
public bool Delete(Sale t)
{
return(saleRepository.Delete(t));
}
public void DeleteSale(int id)
{
var saleEF = saleRepository.GetBy(id);
saleRepository.Delete(saleEF);
}
public IActionResult Delete(long Id)
{
repository.Delete(Id);
return(RedirectToAction("All"));
}
public async Task <bool> DeleteSale(int id)
{
return(await _repo.Delete(id));
}
public async Task Delete(Guid userId, Guid id)
{
var sale = await _saleRepository.GetById(id, x => x.Include(s => s.Details));
if (sale == null)
{
throw new KeyNotFoundException($"Sale with id: {id} not found.");
}
foreach (var detail in sale.Details)
{
var product = await _productRepository.GetById(detail.ProductId);
if (product == null)
{
product = (await _productRepository.FindDeleted(x => x.Id == detail.ProductId)).FirstOrDefault();
}
if (product == null)
{
throw new KeyNotFoundException($"Product with id: {detail.ProductId} not found.");
}
product.Stock += detail.Quantity;
await _productRepository.Update(product);
await _detailRepository.Delete(userId, detail.Id);
}
Payment payment = null;
switch (sale.PaymentType)
{
case Util.Enums.ePaymentTypes.Cash:
payment = await _cashRepository.Delete(userId, sale.PaymentId);
break;
case Util.Enums.ePaymentTypes.OwnFees:
payment = await _ownFeesRepository.Delete(userId, sale.PaymentId);
List <Fee> fees = await _feeRepository.Find(x => x.OwnFeesId == payment.Id);
foreach (var fee in fees)
{
await _feeRepository.Delete(userId, fee.Id);
}
break;
case Util.Enums.ePaymentTypes.CreditCard:
payment = await _creditCardRepository.Delete(userId, sale.PaymentId);
break;
case Util.Enums.ePaymentTypes.DebitCard:
payment = await _debitCardRepository.Delete(userId, sale.PaymentId);
break;
case Util.Enums.ePaymentTypes.Cheques:
payment = await _chequesPaymentRepository.Delete(userId, sale.PaymentId);
List <Cheque> cheques = await _chequeRepository.Find(x => x.ChequesPaymentId == payment.Id);
foreach (var cheque in cheques)
{
await _chequeRepository.Delete(userId, cheque.Id);
}
break;
default:
break;
}
if (payment == null)
{
throw new KeyNotFoundException($"Payment with id: {payment.Id} not found.");
}
await _saleRepository.Delete(userId, id);
await _saleRepository.CommitAsync();
}
public async Task DeleteSale(int id, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
await _saleRepository.Delete(id, cancellationToken);
}
public void DeleteSale(int id)
{
_repoSale.Delete(id);
}
public void DeleteForm(string keyValue)
{
service.Delete(t => t.SellID.ToString() == keyValue);
}
