public async Task <ResultWrapper <DeleteSupplierOutput> > Handle(DeleteSupplierCommand request, CancellationToken cancellationToken)
{
ResultWrapper <DeleteSupplierOutput> result = new ResultWrapper <DeleteSupplierOutput>();
try
{
var tData = await _dbContext.TUser.FirstOrDefaultAsync(x => x.Id == request.UserId && x.Role == Infrastructure.AppEnums.RoleEnum.Supplier);
if (tData == null)
{
result.Status = false;
result.Message = "Supplier doesn't exists";
return(result);
}
_dbContext.TUser.Remove(tData);
await _dbContext.SaveChangesAsync();
result.Status = true;
result.Result = new DeleteSupplierOutput()
{
FireBaseId = tData.FireBaseId
};
}
catch (Exception ex)
{
result.Status = false;
result.Message = ex.Message;
}
return(result);
}
public async Task <ActionResult <bool> > Delete(int supplierId)
{
var command = new DeleteSupplierCommand {
Id = supplierId
};
var result = await mediator.Send(command);
return(result.Success ? (ActionResult <bool>)Ok(result.Success) : BadRequest(result.ErrorMessages));
}
public async Task <ActionResult> DeleteSupplier([FromBody] DeleteSupplierCommand command)
{
var response = await _mediator.Send(command);
if (response.Status.IsSuccessful)
{
return(Ok(response));
}
return(BadRequest(response));
}
public async Task <IActionResult> DeleteSupplier(DeleteSupplierCommand model)
{
FirebaseUser user = HttpContext.GetFirebaseUser();
model.FireBaseId = user.UserId;
ResultWrapper <DeleteSupplierOutput> result = new ResultWrapper <DeleteSupplierOutput>();
result = await _mediator.Send(model);
return(Ok(result));
}
public async Task <IdResponse> HandleAsync(DeleteSupplierCommand cmd, CancellationToken ct)
{
if (cmd.Id.Equals(Guid.Empty))
{
return(IdResponse.Unsuccessful("Id is empty"));
}
var supplier = _supplierRepository.GetById(cmd.id);
var result = _supplierRepository.DeleteByT(supplier);
return(new IdResponse(cmd.Id));
}
public async Task DeleteSupplier()
{
await using var context = DatabaseHelper.CreateInMemoryDatabaseContext(nameof(DeleteSupplier));
var supplierId1Task = context.AddAsync(ValidModelCreator.Supplier());
var supplierId2Task = context.AddAsync(ValidModelCreator.Supplier());
var supplierId3Task = context.AddAsync(ValidModelCreator.Supplier());
var supplier1Id = (await supplierId1Task).Entity.Id;
var supplier2Id = (await supplierId2Task).Entity.Id;
var supplier3Id = (await supplierId3Task).Entity.Id;
var deleteSupplier2Cmd = new DeleteSupplierCommand
{
Id = supplier2Id,
};
var deleteHandler = new DeleteSupplierCommandHandler(context);
var deleteResult1 = await deleteHandler.Handle(deleteSupplier2Cmd, CancellationToken.None);
Assert.True(deleteResult1.Success);
var querySupplier2 = new GetSupplierByIdQuery {
Id = supplier2Id
};
var queryOneHandler = new GetSupplierByIdQueryHandler(context);
var querySupplier2Res = await queryOneHandler.Handle(querySupplier2, CancellationToken.None);
Assert.False(querySupplier2Res.Success);
var deleteResult2 = await deleteHandler.Handle(deleteSupplier2Cmd, CancellationToken.None);
Assert.False(deleteResult2.Success);
var querySupplier1 = new GetSupplierByIdQuery {
Id = supplier1Id
};
var query1Result = await queryOneHandler.Handle(querySupplier1, CancellationToken.None);
Assert.True(query1Result.Success);
var querySupplier3 = new GetSupplierByIdQuery {
Id = supplier3Id
};
var query3Result = await queryOneHandler.Handle(querySupplier3, CancellationToken.None);
Assert.True(query3Result.Success);
}
public void DeleteDimension <TResult>(TResult obj) where TResult : class
{
var resultType = typeof(TResult);
if (resultType == typeof(Customer))
{
var command = new DeleteCustomerCommand
{
Customer = obj as Customer
};
_processXml.Process(command.ToXml());
}
if (resultType == typeof(Supplier))
{
var command = new DeleteSupplierCommand
{
Supplier = obj as Supplier
};
_processXml.Process(command.ToXml());
}
if (resultType == typeof(BalanceSheet))
{
var command = new DeleteGeneralLedgerCommand
{
GeneralLedger = obj as BalanceSheet
};
_processXml.Process(command.ToXml());
}
if (resultType == typeof(ProfitLoss))
{
var command = new DeleteGeneralLedgerCommand
{
GeneralLedger = obj as ProfitLoss
};
_processXml.Process(command.ToXml());
}
if (resultType == typeof(CostCenter))
{
var command = new DeleteCostCenterCommand
{
CostCenter = obj as CostCenter
};
_processXml.Process(command.ToXml());
}
if (resultType == typeof(Article))
{
var command = new DeleteArticleCommand
{
Article = obj as Article
};
_processXml.Process(command.ToXml());
}
if (resultType == typeof(Vat))
{
var command = new DeleteVatCommand
{
Vat = obj as Vat
};
_processXml.Process(command.ToXml());
}
if (resultType == typeof(Currency))
{
var command = new DeleteCurrencyCommand
{
Currency = obj as Currency
};
_processXml.Process(command.ToXml());
}
}
public async Task <IActionResult> Delete([FromBody] DeleteSupplierCommand command)
{
var result = await _mediator.Send(command);
return(Ok(result));
}
