public void DeleteItem(TaskDataBaseItem item)
{
TaskBase task = this.dataBaseItemToTask[item];
this.dataBaseItemToTask.Remove(item);
this.taskToDataBaseItem.Remove(task);
}
private TaskDataBaseItem CreateNewDataBaseItemFromTaskAccordingToType(TaskBase task)
{
TaskDataBaseItem newItem = null;
switch (task.TaskType)
{
case TaskType.RecurringTask:
RecurringTask recurringTask = task as RecurringTask;
newItem = new TaskDataBaseItem()
{
Name = recurringTask.Name,
Description = recurringTask.Description,
TaskType = recurringTask.TaskType,
TimeDue = recurringTask.TimeDue,
Interval = recurringTask.Interval,
TaskOccurences = recurringTask.TaskOccurrences.ToArray()
};
break;
default:
throw new NotSupportedException();
}
return(newItem);
}
private void UpdateTask(TaskBase task)
{
using (var database = new LiteDatabase(DataBasePath))
{
var dataBaseTaskCollection = database.GetCollection <TaskDataBaseItem>(TaskCollectionName);
TaskDataBaseItem dataBaseItem = taskToDataBaseMapper.GetDataBaseItemFromTask(task);
taskToDataBaseMapper.UpdateItemInformation(dataBaseItem);
dataBaseTaskCollection.Update(dataBaseItem);
}
}
private void AddTask(TaskBase task)
{
using (var database = new LiteDatabase(DataBasePath))
{
var dataBaseTaskCollection = database.GetCollection <TaskDataBaseItem>(TaskCollectionName);
TaskDataBaseItem dataBaseItem = taskToDataBaseMapper.GetDataBaseItemFromTask(task);
dataBaseTaskCollection.Insert(dataBaseItem);
}
}
private void RemoveTask(TaskBase task)
{
using (var database = new LiteDatabase(DataBasePath))
{
var dataBaseTaskCollection = database.GetCollection <TaskDataBaseItem>(TaskCollectionName);
TaskDataBaseItem dataBaseItem = taskToDataBaseMapper.GetDataBaseItemFromTask(task);
taskToDataBaseMapper.DeleteItem(dataBaseItem);
dataBaseTaskCollection.Delete(t => t == dataBaseItem);
}
}
public TaskBase GetTaskFromDataBaseItem(TaskDataBaseItem dataBaseItem)
{
if (!this.dataBaseItemToTask.ContainsKey(dataBaseItem))
{
TaskBase newTask = this.CreateNewTaskAccordingToTaskBaseItem(dataBaseItem);
taskToDataBaseItem[newTask] = dataBaseItem;
dataBaseItemToTask[dataBaseItem] = newTask;
}
return(this.dataBaseItemToTask[dataBaseItem]);
}
public TaskDataBaseItem GetDataBaseItemFromTask(TaskBase task)
{
if (!taskToDataBaseItem.ContainsKey(task))
{
TaskDataBaseItem newItem = this.CreateNewDataBaseItemFromTaskAccordingToType(task);
taskToDataBaseItem[task] = newItem;
dataBaseItemToTask[newItem] = task;
}
return(taskToDataBaseItem[task]);
}
public override bool Equals(object obj)
{
TaskDataBaseItem other = obj as TaskDataBaseItem;
if (obj == null)
{
return(false);
}
return(this.Name == other.Name &&
this.Description == other.Description &&
this.TaskType == other.TaskType &&
this.TimeDue == other.TimeDue &&
this.Interval == other.Interval &&
HelperMethods.CollectionEqualsCollection(this.TaskOccurences, other.TaskOccurences));
}
public void UpdateItemInformation(TaskDataBaseItem dataBaseItem)
{
TaskBase task = this.dataBaseItemToTask[dataBaseItem];
dataBaseItem.Name = task.Name;
dataBaseItem.Description = task.Description;
dataBaseItem.TaskType = task.TaskType;
dataBaseItem.TimeDue = task.TimeDue;
switch (task.TaskType)
{
case TaskType.RecurringTask:
RecurringTask recurringTask = task as RecurringTask;
dataBaseItem.Interval = recurringTask.Interval;
dataBaseItem.TaskOccurences = recurringTask.TaskOccurrences.ToArray();
break;
default:
throw new NotSupportedException();
}
}
private TaskBase CreateNewTaskAccordingToTaskBaseItem(TaskDataBaseItem dataBaseItem)
{
TaskBase newTask = null;
switch (dataBaseItem.TaskType)
{
case TaskType.RecurringTask:
RecurringTask newRecurringTask = new RecurringTask(dataBaseItem.Name);
newRecurringTask.Description = dataBaseItem.Description;
newRecurringTask.Interval = dataBaseItem.Interval;
foreach (TaskOccurrence occurrence in dataBaseItem.TaskOccurences)
{
newRecurringTask.AddOccurrence(occurrence.OccurrenceMoment, occurrence.OccurrenceDuration);
}
newTask = newRecurringTask;
break;
default:
throw new NotSupportedException();
}
return(newTask);
}
