public async Task <OutputHandler> DeleteQoute(int qouteId)
{
try
{
var qoute = await _qouteRepository.GetItemAsync(x => x.QouteId == qouteId);
await _qouteRepository.DeleteAsync(qoute);
var deletionresult = await FileHandler.DeleteFileFromFolder(qoute.QouteImg, FolderName);
if (deletionresult.IsErrorOccured)
{
return(deletionresult);
}
await _qouteRepository.SaveChangesAsync();
return(new OutputHandler {
IsErrorOccured = false, Message = "Qoute Deleted Successfully"
});
}
catch (Exception ex)
{
return(StandardMessages.getExceptionMessage(ex));
}
}
public async Task <OutputHandler> DeleteEvent(int eventId)
{
try
{
var output = await _eventRepository.GetItemAsync(x => x.EventId == eventId);
await _eventRepository.DeleteAsync(output);
await _eventRepository.SaveChangesAsync();
var outputHandler = await FileHandler.DeleteFileFromFolder(output.ImageUrl, FolderName);
if (outputHandler.IsErrorOccured) // FILE Deletion failed but updated RECORD deleted
{
return(new OutputHandler
{
IsErrorKnown = true,
IsErrorOccured = true,
Message = "resource deleted successfully, but deleting of old file failed, please alert Techarch Team"
});
}
return(new OutputHandler {
IsErrorOccured = false, Message = "Event Deleted Successfully"
});
}
catch (Exception ex)
{
return(StandardMessages.getExceptionMessage(ex));
}
}
public async Task <OutputHandler> DeleteprojectArm(int projectArmId)
{
try
{
var projectArm = await _projectArmRepository.GetItemAsync(x => x.projectArmId == projectArmId);
await _projectArmRepository.DeleteAsync(projectArm);
await _projectArmRepository.SaveChangesAsync();
var outputHandler = await FileHandler.DeleteFileFromFolder(projectArm.Artwork, FolderName);
if (outputHandler.IsErrorOccured) //Deletion failed but updated saved
{
return(new OutputHandler
{
IsErrorKnown = true,
IsErrorOccured = true,
Message = "Resource deleted successfully, but deleting of old file failed, please alert Techarch Team"
});
}
return(new OutputHandler {
IsErrorOccured = false, Message = "project Arm Deleted Successfully"
});
}
catch (Exception ex)
{
return(StandardMessages.getExceptionMessage(ex));
}
}
public async Task Delete_CategoryWithProducts_ShouldDeleteCategory()
{
// .Arrange
Category category = new Category()
{
CategoryName = Guid.NewGuid().ToString()
};
using (var context = GetLinnworksIntegrationContext())
{
await context.AddAsync(category);
await context.SaveChangesAsync();
await context.AddAsync(new Product()
{
CategoryId = category.Id, Title = Guid.NewGuid().ToString()
});
await context.SaveChangesAsync();
}
// .Act
using (var context = GetLinnworksIntegrationContext())
{
var sut = new GenericRepository <Category>(context);
await sut.DeleteAsync(category.Id);
}
// .Assert
using (var context = GetLinnworksIntegrationContext())
{
Assert.IsNull(context.Find <Category>(category.Id));
}
}
public async Task <OutputHandler> DeleteTestimony(int testimonyId)
{
try
{
var testimony = await _testimonyRepository.GetItemAsync(x => x.TestimonyId == testimonyId);
await _testimonyRepository.DeleteAsync(testimony);
var deletionresult = await FileHandler.DeleteFileFromFolder(testimony.ImageUrl, FolderName);
if (deletionresult.IsErrorOccured)
{
return(deletionresult);
}
await _testimonyRepository.SaveChangesAsync();
return(new OutputHandler {
IsErrorOccured = false, Message = "Testimony Deleted Successfully"
});
}
catch (Exception ex)
{
return(StandardMessages.getExceptionMessage(ex));
}
}
public async Task <OutputHandler> DeleteResource(long resourceId)
{
try
{
var resource = await _resourceRepository.GetItemAsync(x => x.ResourceId == resourceId);
await _resourceRepository.DeleteAsync(resource);
var deletionresult = await FileHandler.DeleteFileFromFolder(resource.ImageUrl, FolderName);
if (deletionresult.IsErrorOccured)
{
return(deletionresult);
}
await _resourceRepository.SaveChangesAsync();
return(new OutputHandler {
IsErrorOccured = false, Message = "Qoute Deleted Successfully"
});
}
catch (Exception ex)
{
return(StandardMessages.getExceptionMessage(ex));
}
}
public async Task ShouldDeleteProduct()
{
Product productMock = new Product()
{
catogeryId = 1,
ProductId = 11,
ProductName = "KotmaleMilkPowder"
};
var services = new ServiceCollection().AddEntityFrameworkInMemoryDatabase();
services.AddSingleton(_mockEnvironment.Object);
services.AddDbContext <ShoppingDBContext>(options =>
{
options.UseInMemoryDatabase("TestDB");
});
var serviceProvider = services.BuildServiceProvider();
using (var scope = serviceProvider.CreateScope())
{
var scopedServices = scope.ServiceProvider;
var shoppingDBContext = scopedServices.GetRequiredService <ShoppingDBContext>();
DbContextSeed.SeedAsync(shoppingDBContext).Wait();
var genericRepository = new GenericRepository <Product>(shoppingDBContext);
var product = await genericRepository.AddAsync(productMock).ConfigureAwait(false);
await genericRepository.DeleteAsync(productMock).ConfigureAwait(false);
Assert.Null(await genericRepository.GetAsync(11).ConfigureAwait(false));
}
}
public async Task <ActionResult> DeleteConfirmed(Int32 id)
{
Person person = await _genericRepository.GetByIdAsync(id);
await _genericRepository.DeleteAsync(person);
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Delete(Int32 id)
{
Student student = await _genericRepository.GetByIdAsync(id);
await _genericRepository.DeleteAsync(student);
return(RedirectToAction("Index"));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
var car = repo.GetDetail(p => p.CarId == id);
await repo.DeleteAsync(car);
await repo.SaveAsync();
return(RedirectToAction("Index"));
}
public async Task Delete_NotExistingCategory_ShouldThrowException()
{
// .Assert
using (var context = GetLinnworksIntegrationContext())
{
var sut = new GenericRepository <Category>(context);
Assert.That(async() =>
// .Act
await sut.DeleteAsync(Guid.NewGuid()), Throws.Exception);
}
}
public async Task Delete_VehicleModelEntity_Succes()
{
var mockContext = new Mock <VehicleContext>();
var mockSet = new Mock <DbSet <VehicleModelEntity> >();
mockContext.Setup(x => x.VehicleModel).Returns(mockSet.Object);
var modelrepository = new GenericRepository <VehicleModelEntity>(mockContext.Object);
var deleteResult = await modelrepository.DeleteAsync(1);
deleteResult.ShouldBeEquivalentTo(1);
}
public async Task <IActionResult> ExecuteAsync(int id, CancellationToken cancellationToken)
{
var item = await _repository.AsyncGetById(id, cancellationToken);
if (item == null)
{
return(new NotFoundResult());
}
await _repository.DeleteAsync(item);
return(new NoContentResult());
}
public async Task GenericRepository_DeleteAsync_ShouldWork()
{
using (GenericRepository <TestModelClass> rep = PrepareDataAndGetRepository())
{
long id = 1;
await rep.DeleteAsync(id);
var queried = rep.GetAll();
queried.Should().HaveCount(_list.Count - 1);
queried.FirstOrDefault(x => x.Id == id).Should().BeNull();
}
}
public Task <ActionResult> DeleteAsync(Guid id)
=> ExecuteAsync(async() =>
{
var assignment = await _assignmentsRepository.GetByIdAsync(id);
if (assignment == null)
{
return(NotFound());
}
BackgroundJob.Delete(assignment.NotificationJobId);
await _assignmentsRepository.DeleteAsync(assignment);
return(Ok());
});
public async Task DeleteAsync_ShouldRemoveEntry()
{
await using var context = BuildTestObjectContext();
var sut = new GenericRepository<TestObject>(context);
var person = new TestObject{FirstName = "Ben", LastName = "Kenobi"};
await context.AddAsync(person);
await context.SaveChangesAsync();
// validate test setup
context.TestObjects.ShouldHaveSingleItem();
await sut.DeleteAsync(person);
context.TestObjects.ShouldBeEmpty();
}
public Task <ActionResult> DeleteAsync(Guid id)
=> ExecuteAsync(async() =>
{
var userId = User.UserId();
var user = await _usersRepository.GetByIdAsync(id);
if (user == null)
{
return(NotFound());
}
await _usersRepository.DeleteAsync(user);
return(Ok());
});
public void TestMethodDeleteCamera()
{
// Act (Do test)
using (var context = new DataContext(options))
{
var repository = new GenericRepository <Camera>(context);
var camera1 = new Camera {
Name = "TestCamera1"
};
repository.DeleteAsync(camera1);
var nullCamera = repository.GetByIdAsync(camera1.Id).Result;
Assert.IsNull(nullCamera);
}
}
public async Task <OutputHandler> DeleteResourceCategory(int sermonId)
{
try
{
var sermon = await _sermonCategoryRepository.GetItemAsync(x => x.ResourceCategoryId == sermonId);
await _sermonCategoryRepository.DeleteAsync(sermon);
await _sermonCategoryRepository.SaveChangesAsync();;
return(new OutputHandler {
IsErrorOccured = false, Message = "Resource Series Deleted Successfully"
});
}
catch (Exception ex)
{
return(StandardMessages.getExceptionMessage(ex));
}
}
public async Task <OutputHandler> DeleteResourceType(int resourceTypeId)
{
try
{
var resource = await _resourcTypeRepository.GetItemAsync(x => x.ResourceTypeId == resourceTypeId);
await _resourcTypeRepository.DeleteAsync(resource);
await _resourcTypeRepository.SaveChangesAsync();;
return(new OutputHandler {
IsErrorOccured = false, Message = "Resource Type Deleted Successfully"
});
}
catch (Exception ex)
{
return(StandardMessages.getExceptionMessage(ex));
}
}
public Task <ActionResult> DeleteAsync(Guid id)
=> ExecuteAsync(async() =>
{
var userId = User.UserId();
var cause = await _causesRepository.GetByIdAsync(id);
if (cause == null)
{
return(NotFound());
}
if (cause.UserId != userId)
{
return(Forbid());
}
await _causesRepository.DeleteAsync(cause);
return(Ok());
});
public Task <ActionResult> DeleteAsync(Guid id)
=> ExecuteAsync(async() =>
{
var userId = User.UserId();
var medication = await _medicationsRepository.GetByIdAsync(id);
if (medication == null)
{
return(NotFound());
}
if (medication.UserId != userId)
{
return(Forbid());
}
await _medicationsRepository.DeleteAsync(medication);
return(Ok());
});
public async Task <OutputHandler> DeletePosition(int positionId)
{
try
{
var position = await _positionRepository.GetItemAsync(x => x.PositionId == positionId);
await _positionRepository.DeleteAsync(position);
await _positionRepository.SaveChangesAsync();;
return(new OutputHandler {
IsErrorOccured = false, Message = "Position Deleted Successfully"
});
}
catch (Exception ex)
{
return(new OutputHandler {
IsErrorOccured = true, Message = "Something went wrong, Please Contact Administrator"
});
}
}
public Task DeleteAsync(int id)
{
return(GenericRepository.DeleteAsync(id));
}
public Task DeleteAsync(int key)
{
return(GenericRepository.DeleteAsync(key));
}
public async Task DeleteAsync(TModel model)
{
var entity = model.Adapt <TEntity>();
await _repository.DeleteAsync(entity);
}
/// <summary>
/// Removes the model from the database
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <bool> DeleteAsync(MyModel model)
{
return(await _genericRepo.DeleteAsync(model));
}
/// <summary>
/// exclui um objeto da base
/// Assíncrono
/// </summary>
/// <param name="ent">T - objeto a ser excluído</param>
/// <returns>Task</returns>
public virtual async Task DeleteAsync(T ent)
{
await genericRepository.DeleteAsync(ent);
}
