refactored storage system that controller handles logic checks

lib/model/repositories/interfaces/task_repository.dart

@@ -1,15 +1,27 @@
 import '../../task.dart';
 
 abstract class TaskRepository {
+  // Create
+
+  Future<void> createTask(Task task);
+
+  Future<void> createTaskOrderEntry(String taskOrder);
+
+  // Read
+
   Future<List<Task>> loadTasks();
 
-  Future<Iterable<String>> loadTaskOrder();
+  Future<List<String>> loadTaskOrder();
 
-  Future<void> saveTaskOrder(List<String> taskOrder);
+  // Update
 
-  Future<void> saveTask(Task task);
+  Future<void> updateTask(Task task);
 
-  Future<void> saveTasks(List<Task> tasks);
+  Future<void> updateTaskOrder(List<String> taskOrder);
+
+  // Delete
 
   Future<void> deleteTask(Task task);
+
+  Future<void> deleteTaskOrderEntry(String taskOrderEntry);
 }

lib/model/repositories/local_repository.dart

@@ -20,55 +20,75 @@ class LocalRepository implements TaskRepository {
     }
   }
 
+  Future<void> _saveTasks(List<Task> tasks) async {
+    final jsonList = tasks.map<String>((e) => jsonEncode(e.toJson())).toList();
+    _prefs!.setStringList(_tasksKey, jsonList);
+  }
+
+  Future<void> _saveTaskOrder(List<String> taskOrder) async {
+    final jsonList = taskOrder.map((e) => jsonEncode(e)).toList();
+    return _prefs!.setStringList(_taskOrderKey, jsonList);
+  }
+
   // Create
 
   @override
-  Future<void> saveTask(Task task) async {
+  Future<void> createTask(Task task) async {
     final tasks = await loadTasks();
-    if (tasks.contains(task)) {
-      tasks.remove(task);
-    } else {
-      final taskOrder = (await loadTaskOrder()).toList();
-      taskOrder.add(task.id);
-      await saveTaskOrder(taskOrder);
-    }
     tasks.add(task);
-    return saveTasks(tasks);
+    return _saveTasks(tasks);
   }
 
   @override
-  Future<void> saveTasks(List<Task> tasks) async {
+  Future<void> createTaskOrderEntry(String taskOrderEntry) async {
-    final jsonList = tasks.map<String>((e) => jsonEncode(e.toJson())).toList();
+    final taskOrder = await loadTaskOrder();
-    return _prefs!.setStringList(_tasksKey, jsonList);
+    taskOrder.add(taskOrderEntry);
-  }
+    return _saveTaskOrder(taskOrder);
-
-  @override
-  Future<void> saveTaskOrder(Iterable<String> taskOrder) {
-    final jsonList = taskOrder.map<String>((e) => jsonEncode(e)).toList();
-    return _prefs!.setStringList(_taskOrderKey, jsonList);
   }
 
   // Read
 
-  @override
-  Future<Iterable<String>> loadTaskOrder() async {
-    final Iterable<String> jsonList =
-        _prefs!.getStringList(_taskOrderKey) ?? [];
-    return jsonList.map<String>((e) => jsonDecode(e));
-  }
-
   @override
   Future<List<Task>> loadTasks() async {
     final Iterable<String> jsonList = _prefs!.getStringList(_tasksKey) ?? [];
     return jsonList.map<Task>((e) => Task.fromJson(jsonDecode(e))).toList();
   }
 
+  @override
+  Future<List<String>> loadTaskOrder() async {
+    final Iterable<String> jsonList =
+        _prefs!.getStringList(_taskOrderKey) ?? [];
+    return jsonList.map<String>((e) => jsonDecode(e)).toList();
+  }
+
+  // Update
+
+  @override
+  Future<void> updateTask(Task task) async {
+    final tasks = await loadTasks();
+    tasks.remove(task);
+    tasks.add(task);
+    return _saveTasks(tasks);
+  }
+
+  @override
+  Future<void> updateTaskOrder(List<String> taskOrder) async {
+    return _saveTaskOrder(taskOrder);
+  }
+
   // Delete
 
   @override
   Future<void> deleteTask(Task task) async {
     final tasks = await loadTasks();
     tasks.remove(task);
-    saveTasks(tasks);
+    return _saveTasks(tasks);
+  }
+
+  @override
+  Future<void> deleteTaskOrderEntry(String taskOrderEntry) async {
+    final taskOrder = await loadTaskOrder();
+    taskOrder.remove(taskOrderEntry);
+    return _saveTaskOrder(taskOrder);
   }
 }

lib/service/task_controller.dart

@@ -25,16 +25,31 @@ class TaskController extends ChangeNotifier {
   Future<void> reorderTask(int oldIndex, int newIndex) async {
     final taskId = _taskOrder.removeAt(oldIndex);
     _taskOrder.insert(newIndex, taskId);
-    _repository.saveTaskOrder(_taskOrder);
+    _repository.updateTaskOrder(_taskOrder);
   }
 
   Future<void> saveTask(Task task) async {
-    await _repository.saveTask(task);
+    if (_tasks.contains(task)) {
-    await _loadTasks();
+      _tasks.remove(task);
-    await _loadTaskOrder();
+      _tasks.add(task);
+      _repository.updateTask(task);
+    } else {
+      _tasks.add(task);
+      _taskOrder.add(task.id);
+      _repository.createTask(task);
+      _repository.updateTaskOrder(_taskOrder);
+    }
     notifyListeners();
   }
 
+  Future<void> deleteTask(Task task) async {
+    _tasks.remove(task);
+    _taskOrder.remove(task.id);
+    notifyListeners();
+    _repository.deleteTask(task);
+    _repository.updateTaskOrder(_taskOrder);
+  }
+
   Future<void> _loadTasks() async {
     _tasks.clear();
     return _repository.loadTasks().then((value) => _tasks.addAll(value));