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); }