public void TestDeleteValidNews()
{
var news = new News
{
Title = "Test News",
Content = "This is very important"
};
newsRepo.Add(news);
newsRepo.SaveChanges();
Assert.IsNotNull(newsRepo.Find(news.Id));
newsRepo.Delete(news.Id);
newsRepo.SaveChanges();
Assert.IsNull(newsRepo.Find(news.Id));
}
public void DeleteNewsByNewsId(int id)
{
NewsImageService imageService = new NewsImageService();
using (var transaction = dbContext.Database.BeginTransaction())
{
try
{
var news = GetNewsById(id);
if (news != null)
{
var newsImages = imageService.GetNewsImageByNewsId(news.Id);
foreach (NewsImage images in newsImages)
{
NewsImageRepository.Delete(images);
}
Save();
}
NewsRepository.Delete(news);
Save();
transaction.Commit();
//return order.ID;
}
catch (Exception ex)
{
transaction.Rollback();
throw ex.InnerException;
}
}
}
public IHttpActionResult Post(int id, string method)
{
using (NewsRepository _repo = new NewsRepository(UnitOfWork))
{
_repo.Delete(id);
UnitOfWork.Save();
}
return Ok();
}
public IHttpActionResult Post(int id, string method)
{
using (NewsRepository _repo = new NewsRepository(UnitOfWork))
{
_repo.Delete(id);
UnitOfWork.Save();
}
return(Ok());
}
public ActionResult DeleteConfirmed(int id)
{
if (NewsRepository.Delete(NewsRepository.GetNewByID(id)))
{
return(RedirectToAction("Index"));
}
else
{
return(View(NewsRepository.GetNewByID(id)));
}
}
public void DeleteNews_WhenNewsIsValid_ShouldDeleteNews()
{
var repo = new NewsRepository(new NewsEntities());
var news = repo.All().Where(n => n.Title == "News1").FirstOrDefault();
repo.Delete(news);
repo.SaveChanges();
var newsFromRepo = repo.Find(news.Id);
Assert.AreEqual(null, newsFromRepo);
}
public void DeleteNews_WhenNewsIsNonExisting_ShouldThrowException()
{
var repo = new NewsRepository(new NewsEntities());
var news = new News.Models.News
{
Title = "title",
Content = "content",
PublishDate = DateTime.Now
};
repo.Delete(news);
repo.SaveChanges();
}
public IActionResult Delete(int id)
{
var existingNews = _newsRepository.Get(id);
if (existingNews == null)
{
return(NotFound());
}
_newsRepository.Delete(existingNews);
return(NoContent());
}
public ActionResult Delete(int id, News news)
{
try
{
// TODO: Add delete logic here
nRepo.Delete(id);
return(RedirectToAction("AdminIndex"));
}
catch
{
return(View());
}
}
public async Task <IActionResult> Delete(int id)
{
if (ModelState.IsValid)
{
try
{
var item = await _repo.FindBy(i => i.Id == id).SingleAsync();
_repo.Delete(item);
}
catch (Exception ex)
{
_logger.LogError($"Error deleting item with id {id}: " + ex.Message);
return(BadRequest("Failed to delete!"));
}
if (await _repo.SaveChangesAsync())
{
return(Ok($"RSS item with id {id} deleted successfully"));
}
}
_logger.LogError($"Error deleting item with id {id}");
return(BadRequest("Failed to delete!"));
}
public async System.Threading.Tasks.Task <OperationResult <News> > DeleteNews(int id)
{
return(await System.Threading.Tasks.Task.Factory.StartNew <OperationResult <News> >(() =>
{
OperationResult <News> result = new OperationResult <News>();
try
{
News news = NewsRepository.Read(id);
if (news != null)
{
if (IsInCompany(news.CompanyId))
{
result.Result = NewsRepository.Delete(id);
}
}
}
catch (Exception ex)
{
LoggingService.Log(ex);
}
return result;
}));
}
/// <summary>
/// Delete articles older than MAX_ARTICLE_AGE_IN_DAYS from repository
/// </summary>
/// <returns>Count of deleted articles</returns>
internal async Task <int> delete()
{
// counter
int deletedPosts = 0;
// look for too old articles in db
DateTime dateOld = DateTime.UtcNow.Subtract(new TimeSpan(MAX_ARTICLE_AGE_IN_DAYS, 0, 0, 0));
// gather id's
var oldArticleIds = from a in _repo.Query <Article>()
where a.Date < dateOld
select a.ArticleId;
// delete
foreach (var id in oldArticleIds)
{
_repo.Delete <Article>(id);
deletedPosts++;
}
// commit
if (deletedPosts > 0)
{
await _repo.CommitAsync();
}
return(deletedPosts);
}
public void DeleteNews(long id)
{
newsRepository.Delete(x => x.Id == id);
}
public IActionResult Delete(int id)
{
var result = _newsRepository.Delete(id);
return(RedirectToAction("Index"));
}
public void DeleteNews(int id)
{
_repository = new NewsRepository();
tb_News dbNews = _repository.GetSingle(d => d.News_Id == id);
_repository.Delete(dbNews);
}
public ActionResult DeleteNews(int id)
{
_news.Delete(id);
return(RedirectToAction("News", "News"));
}
public void DeleteNews_WhenDeletingNonExistingNews_ShouldThrowException()
{
var context = new NewsContext();
context.News.Delete();
context.SaveChanges();
var repo = new NewsRepository(context);
var newsToDelete = repo.Find(1);
repo.Delete(newsToDelete);
repo.SaveChanges();
}
public void Delete_Non_Existing_Data_Should_Throw_Exception()
{
NewsRepository repo = new NewsRepository(new NewsContext());
var newsFromDB = repo.GetAll().FirstOrDefault(n => n.Id == 1500);
repo.Delete(newsFromDB);
repo.SaveChanges();
}
/// <summary>
/// Deletes a news entry for the admin homepage
/// </summary>
/// <param name="entryID">The entryID to remove</param>
public void Delete(int entryID)
{
var data = new NewsRepository();
data.Delete(entryID);
}
public bool DeleteMapping(object id)
{
repository.Delete(id);
return(true);
}
public static bool Delete(int id)
{
INewsRepository newsRepo = new NewsRepository();
return(newsRepo.Delete(id));
}
public void Delete <E>(E id)
{
NewsRepository.Delete(id);
}
public ResponseModel Delete(EntityModel.News news)
{
return(_newsRepository.Delete(news));
}
public bool DeleteFeedback(object id)
{
repository.Delete(id);
return(true);
}
// DELETE api/newsApi/
public void Delete(int id)
{
newsRepository.Delete(id);
}
public async Task Delete(int id)
{
await _newsRepository.Delete(id);
}
public void DeleteExistingNews()
{
var repo = new NewsRepository(new NewsContext());
var newsFromDb = repo.Find(1);
repo.Delete(newsFromDb);
repo.SaveChanges();
Assert.IsNull(repo.Find(1));
}
public void Delete_Existing_Data_Should_Delete_The_Data()
{
NewsRepository repo = new NewsRepository(new NewsContext());
var news = new NewsRecord()
{
Title = "UnModifiedShit",
Content = "See me updated",
PublishDate = new DateTime(2015, 08, 30, 14, 04, 30)
};
repo.Add(news);
repo.SaveChanges();
var countBeforeDeletion = repo.GetAll().Count();
var newsFromDB = repo.GetAll().FirstOrDefault(n => n.Title == "UnModifiedShit");
repo.Delete(newsFromDB);
repo.SaveChanges();
Assert.AreEqual(countBeforeDeletion - 1, repo.GetAll().Count());
}
public void TryToDeleteNonExistingNews()
{
var repo = new NewsRepository(new NewsContext());
var newsFromDb = repo.Find(5);
repo.Delete(newsFromDb);
}
public bool DeleteComment(object id)
{
repository.Delete(id);
return(true);
}
public void DeleteNews_WhenDeletingExistingNews_ShouldDeleteNews()
{
var context = new NewsContext();
context.News.Delete();
var news = new Models.News()
{
Title = "Murder",
Content = "A man was slaughterd in Sofia last night.",
PublishDate = DateTime.Now
};
context.News.Add(news);
context.SaveChanges();
var repo = new NewsRepository(context);
repo.Delete(news);
repo.SaveChanges();
var newsFromDb = repo.All().ToArray();
Assert.AreEqual(0, newsFromDb.Count());
}
public bool DeleteUser(object id)
{
repository.Delete(id);
return(true);
}
public ActionResult DeleteNews(int id)
{
news_repo.Delete(news_repo.GetByID(id));
return(RedirectToAction("ListNews"));
}
