public AddressDto Delete(IObjectIdentifier <ulong> id)
{
var address = _repository.FindById(id);
_repository.Delete(address.Id);
return(AddressDto.FromDomain(address));
}
private ViewResult DeleteUser(int deleteUserID)
{
User usr = userRepository.GetUser(deleteUserID);
System.Diagnostics.Debug.WriteLine("-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-");
System.Diagnostics.Debug.WriteLine(deleteUserID);
userRepository.Delete(deleteUserID);
addrRepository.Delete(usr.AddressID);
return(View("Administrator", repository));
}
public void CheckAddressRemoved(List <Address> listAdress, Guid idPerson)
{
var oldList = _repository.GetAllByPerson(idPerson);
foreach (var address in oldList)
{
if (!listAdress.Contains(address))
{
_repository.Delete(address);
}
}
}
public IHttpActionResult Delete([FromODataUri] System.Guid key)
{
logger.Trace("Call AddressController Delete");
AddressRepository.Delete(key);
return(Ok());
}
public ActionResult DeleteConfirmed(int id)
{
addressRepository.Delete(id);
addressRepository.Save();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Delete(int id)
{
var location = GetCotrollerActionNames();
try
{
if (id < 1)
{
return(BadRequest());
}
var isExist = await _addressRepository.IsExist(id);
if (!isExist)
{
return(NotFound());
}
var address = await _addressRepository.FindById(id);
await _addressRepository.Delete(address);
return(NoContent());
}
catch (Exception e)
{
return(InternalServerError($"{location}: {e.Message} - {e.InnerException}"));
}
}
public async Task <ActionResult> Delete(int id)
{
try
{
var exist = await _addressRepository.One(id);
if (exist == null)
{
return(NotFound("This address has not been found."));
}
var data = await _addressRepository.Delete(id);
if (data == false)
{
return(BadRequest("This address could not be removed."));
}
return(Ok("This address has been removed."));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task <bool> Delete(Guid id)
{
if (!_companyRepository.Get(c => c.Id == id).Result.Any())
{
Notify("Company does not exists.");
return(false);
}
if (_companyRepository.GetCompanyJobOffersAddress(id).Result.JobOffers.Any())
{
Notify("The company has registered contracts.");
return(false);
}
var address = await _addressRepository.GetAddressByCompany(id);
await _companyRepository.Delete(id);
if (address != null)
{
await _addressRepository.Delete(address.Id);
}
return(true);
}
public ActionResult DeleteConfirmed(int id)
{
Address address = _addressRepository.GetWhere(x => x.Id == id).FirstOrDefault();
_addressRepository.Delete(address);
return(RedirectToAction("Index"));
}
public IActionResult Delete(int id)
{
Customer _customerDb = _customerRepository.GetSingle(id);
if (_customerDb == null)
{
return(new NotFoundResult());
}
else
{
IEnumerable <PhoneNumber> _phoneNumbers = _phoneNumberRepository.FindBy(a => a.CustomerId == id);
IEnumerable <Address> _addresses = _addressRepository.FindBy(s => s.CustomerId == id);
foreach (var phoneNumber in _phoneNumbers)
{
_phoneNumberRepository.Delete(phoneNumber);
}
foreach (var address in _addresses)
{
_addressRepository.Delete(address);
}
_customerRepository.Delete(_customerDb);
_customerRepository.Commit();
return(new NoContentResult());
}
}
public HttpResponseMessage Delete(long id)
{
_addressRepository.Delete(id);
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK);
return(response);
}
public IActionResult DeleteAddress(int id)
{
//doe hier de delete
var address = _addressRepository.GetAddressById(id);
_addressRepository.Delete(address);
return(RedirectToAction("AddressManagement"));
}
public bool Delete(int Id)
{
if (_addressRepo.Delete(Id) > 0)
{
return(true);
}
return(false);
}
public void Delete(int id)
{
var entity = addressRepository.Get(id);
if (entity != null)
{
addressRepository.Delete(entity);
}
}
public bool AddressDelete(Address address)
{
return(ExecuteFaultHandledOperation(() =>
{
var address_data = _addr_es.Map(address);
_address_repo.Delete(address_data);
return true;
}));
}
public IActionResult Delete(int addressId)
{
if (!addressRepository.Delete(addressId))
{
return(BadRequest("Could not delete"));
}
return(RedirectToAction("Index"));
}
public async Task <RedirectToRouteResult> DeleteAddress(int addressId)
{
ShoppingAddress address = addressRepository.FindById(addressId);
String userId = address.UserID;
addressRepository.Delete(address);
await addressRepository.Save();
return(RedirectToAction("List", new { userId = userId }));
}
public IActionResult Delete(AddressViewModel addressViewModel)
{
if (ModelState.IsValid)
{
var address = _addressRepository.GetById(addressViewModel.Id);
_addressRepository.Delete(address);
return(RedirectToAction("index"));
}
return(View());
}
public async Task Delete(Guid id)
{
LegalPerson person = await _legalPersonRepository.GetById(id);
_legalPersonRepository.Delete(person);
_addressRepository.Delete(person.Address);
_documentRepository.Delete(person.Document);
await _unitOfWork.Commit();
}
public IActionResult Delete(string id)
{
Address addressDb = _address.Get(id);
if (addressDb != null)
{
_address.Delete(addressDb);
}
return(NotFound(new { message = "Endereço não encontrado" }));
}
public void Delete(int id)
{
Customer item = GetCustomer(id);
foreach (var address in item.Addresses)
{
addressRepository.Delete(address.Id);
}
database.Remove(item);
database.SaveChanges();
}
public CommandResult Handle(DeleteAddressCommand command)
{
var result = command.Validate();
if (result.IsValid)
{
//var address = new Address(command.Id, command.Street, command.City, command.State, command.Country, command.ZipCode, command.Type);
_repository.Delete(command.Id);
}
return(result);
}
public async Task <IActionResult> DeleteAddress(int id)
{
Address address = await _addressRepository.FindAsync(id);
if (address == null)
{
return(NotFound());
}
_addressRepository.Delete(address);
return(NoContent());
}
public bool DeleteAddress(int id)
{
var address = _addressRepository.Get(id);
if (address == null)
{
return(false);
}
_addressRepository.Delete(address);
_addressRepository.Save();
return(true);
}
public async Task <IActionResult> DeleteAddress(AddressCreationDto dto)
{
try
{
await _addressRepository.Delete(dto);
return(Ok());
}
catch (Exception e)
{
return(NotFound("This Address cannot be delete"));
}
}
public IActionResult Delete(int id)
{
var address = _db.Get(id);
if (address == null)
{
return(BadRequest(ModelState));
}
_db.Delete(id);
return(Ok(address));
}
public bool Delete(Guid id)
{
var address = _addressRepository.Get(id);
if (address is null)
{
return(false);
}
_addressRepository.Delete(address);
_uow.Commit();
return(true);
}
public bool Delete(int id, string accountId)
{
var userAddress = _userRepository.GetUserAddressById(id, accountId);
if (userAddress == null)
{
return(false);
}
_addressRepository.Delete(userAddress);
_addressRepository.Save();
return(true);
}
public async Task <IActionResult> DeleteConfirmed(string id)
{
var address = await _addressRepo.GetById(id);
if (address == null)
{
return(NotFound());
}
_addressRepo.Delete(address);
await _uow.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
public ActionResult Delete(int Id)
{
var Person = _personRepository.GetById(Id);
var Address = _addressRepository.GetById(Id);
_personRepository.Delete(Person);
_personRepository.Save();
Address.AddressId = Person.PersonId;
_addressRepository.Delete(Address);
_personRepository.Save();
return(RedirectToAction("EmployeeDetails"));
}
