public async Task <IActionResult> DeletePhoto(int id)
        {
            var photoFromRepo = await _repo.GetPhoto(id);

            if (photoFromRepo.PublicId != null)
            {
                var deleteParams = new DeletionParams(photoFromRepo.PublicId);

                var result = _cloudinary.Destroy(deleteParams);

                if (result.Result == "ok")
                {
                    _repo.Delete(photoFromRepo);
                }
            }

            if (photoFromRepo.PublicId == null)
            {
                _repo.Delete(photoFromRepo);
            }

            if (await _repo.SaveAll())
            {
                return(Ok());
            }

            return(BadRequest("Failed to delete the photo"));
        }
        public async Task <IActionResult> DeleteBom(string name)
        {
            var bomName = await _repo.GetBomName(name);

            if (bomName != null)
            {
                _search.Delete(bomName);
            }

            if (await _search.SaveAll())
            {
                return(Ok());
            }


            return(BadRequest("Failed to delete"));
        }
        public void Delete_NotExistingObject_Return_LuceneSearchRepositoryException()
        {
            sut = new LuceneSearchRepository(true);
            foreach (var user in users)
            {
                sut.Insert(user);
            }
            var oldUser = new TestUser();

            Assert.Throws <LuceneSearchRepositoryException>(() => sut.Delete <TestUser>(oldUser));
        }
        public void Delete_UpdateObject_Return_NoException()
        {
            sut = new LuceneSearchRepository(true);
            foreach (var user in users)
            {
                sut.Insert(user);
            }
            var oldUser = users.ToList()[1];

            sut.Delete <TestUser>(oldUser);
        }
        public void Delete_UpdateObject_Return_EqualKeyValue()
        {
            sut = new LuceneSearchRepository(true);
            foreach (var user in users)
            {
                sut.Insert(user);
            }
            var oldUser = users.ToList()[1];

            sut.Delete <TestUser>(oldUser);
            var updUser = sut.GetById <TestUser>(oldUser.Id);

            Assert.AreEqual(null, updUser);
        }
        /// <summary>
        /// Detectes changes and save it to Lucene using LuceneSearchRepository
        /// </summary>
        /// <param name="types">Object type that needed to detect and save</param>
        protected void DetectAndSaveChanges(params Type[] types)
        {
            foreach (var entry in ChangeTracker.Entries())
            {
                if (!types.Contains(entry.Entity.GetType()))
                {
                    continue;
                }

                switch (entry.State)
                {
                case EntityState.Added:
                    _searchRepository.Insert(entry.Entity); break;

                case EntityState.Modified:
                    _searchRepository.Update(entry.Entity); break;

                case EntityState.Deleted:
                    _searchRepository.Delete(entry.Entity); break;
                }
            }
        }
Beispiel #7
0
 public void Delete(long id)
 {
     _searchRepository.Delete(id);
 }
Beispiel #8
0
 /// <summary>
 /// Removes object from repository
 /// </summary>
 /// <typeparam name="TEntity"></typeparam>
 /// <param name="model"></param>
 public void RemoveFromSearchIndex <TEntity>(TEntity model) where TEntity : class
 {
     _repository.Delete(model);
 }