public void Delete(Provider provider, User user)
{
user.CheckPermission(Permission.Provider_Delete);
CheckPossibilityToDelete(provider);
var contractList = new List <Contract>(provider.Contracts);
foreach (Contract contract in contractList)
{
ProviderContract providerContract = contract.As <ProviderContract>();
provider.RemoveProviderContract(providerContract);
providerContractRepository.Delete(providerContract);
}
var contractorOrganizationList = new List <ContractorOrganization>(provider.Organizations);
foreach (ContractorOrganization contractorOrganization in contractorOrganizationList)
{
ProviderOrganization providerOrganization = contractorOrganization.As <ProviderOrganization>();
provider.RemoveContractorOrganization(providerOrganization);
}
providerRepository.Delete(provider);
}
[HttpDelete("eliminar/{id:int}")] // Metodo DELETE para eliminar elemento
public IActionResult Delete(int id)
{
var provider = _providerRepository.Delete(id); // Eliminar elemento
var providerDto = _mapper.Map <ProviderDto>(provider); // Mapear entitidad a dto
return(Ok(providerDto));
}
/// <summary>
/// Servicio que elimina una entidad Provider (Provider) dado su Id
/// </summary>
/// <param name="id">Id de la entidad a eliminar</param>
/// <param name="user">Usuario que elimina la entidad</param>
public virtual void Delete(int id, string user)
{
using (var dbContextScope = new TiendaDbContext())
{
_repository.Delete(id, user);
dbContextScope.SaveChanges();
}
}
public void DeleteProvider(List <Provider> provider)
{
foreach (var item in provider)
{
_providerRepository.Delete(item);
}
_unitOfWork.Commit();
}
public bool DeleteProvider(ProviderDto request)
{
if (request.ProviderId == default)
{
throw new IdCannotNullOrEmptyException();
}
ValidateProviderIdExist(request);
return(_repoProvider.Delete(_mapper.Map <ProviderEntity>(request)));
}
public async Task <bool> DeleteProvider(ProviderDto provider)
{
var ProviderToDelete = await _providerRepo.GetOne <ProviderEntity>(x => x.IdProvider == provider.IdProvider).ConfigureAwait(false);
if (ProviderToDelete != null)
{
await _providerRepo.Delete(ProviderToDelete);
return(true);
}
throw new NoExistingProviderException("No existe el proovedor a eliminar");
}
public async Task <IActionResult> Delete(Guid id)
{
var result = await providerRepository.FindByKey(id);
if (result == null)
{
return(NotFound());
}
await providerRepository.Delete(result);
return(Ok());
}
public async Task <IActionResult> DeleteConfirmed(Guid id)
{
ProviderViewModel providerViewModel = await GetProviderProductAddress(id);
if (providerViewModel == null)
{
return(NotFound());
}
await _providerRepository.Delete(id);
return(RedirectToAction(nameof(Index)));
}
public async Task <bool> Delete(Guid id)
{
var providerProducts = await _providerRepository.GetProviderAddressProduct(id);
if (providerProducts.Products.Any())
{
Notify("O Fornecedor possui produtos cadastrados");
return(false);
}
await _providerRepository.Delete(id);
return(true);
}
public void Delete(int id)
{
_providerRepository.Delete(id);
}
public void Delete(Guid id)
{
providerRepository.Delete(id);
}
public bool Delete(long id)
{
return(_providerRepository.Delete(id));
}
public Provider Delete(int id)
{
return(_providerRepository.Delete(id));
}
public void Delete(int id)
{
_providerRepository.Delete(id);
_eventAggregator.PublishEvent(new ProviderDeletedEvent <TProvider>(id));
}
public void Delete(int id)
{
_providerRepo.Delete(id);
}
public void Delete(Provider provider)
{
_providerRepository.Delete(provider);
_contextProvider.CommitChanges();
}
public async Task Delete(Provider provider)
{
_providerRepository.Delete(provider);
await _providerRepository.UnitOfWork.SaveChangesAsync().ConfigureAwait(false);
}