public bool DelTask(IdDTO iddto, Guid id)
{
TasksRepository repository = new TasksRepository();
var taskId = iddto.Id;
var tasks = repository.GetItem(taskId);
if (tasks != null)
{
repository.Delete(taskId);
var tasks2 = repository.GetItem(taskId);
if (tasks2 == null)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
internal Tasky Delete(int id)
{
var data = GetById(id);
_repo.Delete(id);
return(data);
}
/// <summary>
/// Update gantt tasks
/// </summary>
/// <param name="ganttData">GanttData object</param>
private void UpdateTasks(GanttRequest ganttData)
{
switch (ganttData.Action)
{
case GanttAction.Inserted:
// add new gantt task entity
//db.Tasks.Add(ganttData.UpdatedTask);
TasksRepository.Insert(ganttData.UpdatedTask);
break;
case GanttAction.Deleted:
// remove gantt tasks
//db.Tasks.Remove(db.Tasks.Find(ganttData.SourceId));
TasksRepository.Delete(ganttData.UpdatedTask);
break;
case GanttAction.Updated:
// update gantt task
//db.Entry(db.Tasks.Find(ganttData.UpdatedTask.Id)).CurrentValues.SetValues(ganttData.UpdatedTask);
TasksRepository.Update(ganttData.UpdatedTask);
break;
default:
ganttData.Action = GanttAction.Error;
break;
}
}
public void DeleteTasks()
{
using (var fixture = new FixtureInit("http://localhost"))
{
//INIT
var repository = new TasksRepository(fixture.Setup.Context);
var task = new Task()
{
Number = 0,
UserId = fixture.Setup.User.Id,
Description = "My new task",
Status = 0,
ActualWork = 0
};
repository.Save(task);
//ACT
repository.Delete(task);
//POST
var foundTask = repository.Tasks.WithId(task.Id);
Assert.That(foundTask, Is.Null);
}
}
public ActionResult Delete(int id)
{
TasksRepository repo = new TasksRepository();
repo.Delete(id);
return(RedirectToAction("List"));
}
internal void Delete(int id)
{
var data = _repo.GetById(id);
if (data == null)
{
throw new Exception("Invalid Id");
}
_repo.Delete(id);
}
public async Task <ActionResult <Tasks> > Delete(int id)
{
var movie = await repository.Delete(id);
if (movie == null)
{
return(NotFound());
}
return(movie);
}
public ActionResult Delete(int id)
{
if (ModelState.IsValid)
{
repository.Delete(id);
}
return(RedirectToAction("Index", "Task"));
}
public void Delete()
{
Tasks tasks = TasksRepository.RetrieveByPK(task2Delete);
if (tasks != null)
{
TasksRepository.Delete(tasks);
}
Assert.Greater(TasksRepository.SaveChanges(), 0);
}
public void DeleteUser()
{
Console.Clear();
Console.Write("Enter user id to delete: ");
int id = 0;
bool isInt = int.TryParse(Console.ReadLine(), out id);
while (isInt == false)
{
Console.WriteLine("Only numbers can be entered for user ID's");
isInt = int.TryParse(Console.ReadLine(), out id);
}
UsersRepository userRepo = new UsersRepository("users.txt");
if (userRepo.CheckEntityExistence(User => User.Id == id) == false)
{
Console.WriteLine("No user with that id exists!!");
Console.ReadKey(true);
return;
}
if (id == 1)
{
Console.WriteLine("You cannot delete the built-in administrator account!!");
Console.ReadKey(true);
return;
}
CommentsRepository commentRepo = new CommentsRepository("comments.txt");
List <Comment> comments = commentRepo.GetAll(Comment => Comment.CreatorId == id);
foreach (Comment comment in comments)
{
commentRepo.Delete(comment);
}
TasksRepository taskRepo = new TasksRepository("tasks.txt");
List <Task> tasks = taskRepo.GetAll(Task => Task.CreatorId == id || Task.AssigneeId == id);
foreach (Task task in tasks)
{
taskRepo.Delete(task);
}
List <User> users = userRepo.GetAll(User => User.Id == id);
foreach (User user in users)
{
userRepo.Delete(user);
}
Console.WriteLine("User successfully deleted!");
Console.ReadKey(true);
}
public async Task <ActionResult <TasksViewModel> > Delete(int id)
{
var task = await _repository.Delete(id);
if (task == null)
{
return(NotFound());
}
TasksViewModel maped = _mapper.Map <TasksViewModel>(task);
return(Ok(maped));
}
public ActionResult DeleteTask(int id)
{
if (AuthenticationManager.LoggedUser == null)
{
return(RedirectToAction("Login", "Home"));
}
TasksRepository tasksRepository = new TasksRepository(new TaskManagerDb());
Task task = tasksRepository.GetById(id);
tasksRepository.Delete(task);
return(RedirectToAction("Index", "TasksManager"));
}
public JsonResult Destroy()
{
var tasks = this.DeserializeObject <IEnumerable <TaskViewModel> >("models");
if (tasks != null)
{
foreach (var task in tasks)
{
TasksRepository.Delete(task);
}
}
return(this.Jsonp(tasks));
}
public void DeleteTasks()
{
Console.Clear();
Console.Write("Enter task id to delete: ");
int inputId = 0;
bool isInt = int.TryParse(Console.ReadLine(), out inputId);
while (isInt == false)
{
Console.WriteLine("You can only enter integers for task ID's!!");
Console.Write("Enter task id to delete: ");
isInt = int.TryParse(Console.ReadLine(), out inputId);
}
TasksRepository taskRepo = new TasksRepository("tasks.txt");
List <Task> tasks = taskRepo.GetAll(Task => Task.Id == inputId);
if (tasks.Count == 0)
{
Console.WriteLine("No tasks with that Id found.");
Console.ReadKey(true);
}
else if (tasks[0].CreatorId != AuthenticationService.LoggedUser.Id)
{
Console.WriteLine("You cannot delete a task which was not created by you!!");
Console.ReadKey(true);
}
else
{
foreach (Task task in tasks)
{
taskRepo.Delete(task);
}
Console.WriteLine("Task successfully deleted!");
Console.ReadKey(true);
}
}
public async System.Threading.Tasks.Task <OperationResult <Task> > DeleteTask(int id)
{
return(await System.Threading.Tasks.Task.Factory.StartNew <OperationResult <Task> >(() =>
{
OperationResult <Task> result = new OperationResult <Task>();
try
{
Task task = TasksRepository.Read(id);
if (task != null)
{
if (IsInCompany(task.CompanyId))
{
result.Result = TasksRepository.Delete(id);
}
}
}
catch (Exception ex)
{
LoggingService.Log(ex);
}
return result;
}));
}
private void Delete()
{
TasksRepository tasksRepository = new TasksRepository("tasks.txt");
Console.Clear();
Console.WriteLine("Delete Task:");
Console.Write("Task Id: ");
int taskId = Convert.ToInt32(Console.ReadLine());
TaskData task = tasksRepository.GetById(taskId);
if (task == null)
{
Console.WriteLine("Task not found!");
}
else
{
tasksRepository.Delete(task);
Console.WriteLine("Task deleted successfully.");
}
Console.ReadKey(true);
}
public void TearDown()
{
var data = _repository.GetAll();
data.ToList().ForEach(task => { _repository.Delete(task.Id); });
}
public void Delete(int id)
{
repo.Delete(id);
}
public bool Delete(int taskId)
{
return(_repo.Delete(taskId));
}
public void CleanUp()
{
_repository.Delete(_taskOne.Id);
_repository.Delete(_taskTwo.Id);
}
internal object Delete(int id)
{
Task found = GetOne(id);
return(_repo.Delete(id));
}
